From 9425552e5e863d6a77086b10071f4f3927d48607 Mon Sep 17 00:00:00 2001 From: Bernhard M. Wiedemann Date: Dec 07 2020 08:10:55 +0000 Subject: update 2020-01-02 14:30 --- diff --git a/.files b/.files index c3b7429..4e5cd85 100644 Binary files a/.files and b/.files differ diff --git a/.rev b/.rev index 77ef1da..bbf4836 100644 --- a/.rev +++ b/.rev @@ -1573,4 +1573,12 @@ 751231 + + ee25d040f643c4757a297b2055b3e506 + 1.2.1.2 + + dimstar_suse + + 758568 + diff --git a/0001-alsa.m4-Fix-the-detection-of-topology-library-availa.patch b/0001-alsa.m4-Fix-the-detection-of-topology-library-availa.patch deleted file mode 100644 index 2a8596a..0000000 --- a/0001-alsa.m4-Fix-the-detection-of-topology-library-availa.patch +++ /dev/null @@ -1,28 +0,0 @@ -From be02b903b8aaa3a9b99b8de9608bce3c4eb13f63 Mon Sep 17 00:00:00 2001 -From: Takashi Iwai -Date: Wed, 27 Nov 2019 10:19:26 +0100 -Subject: [PATCH] alsa.m4: Fix the detection of topology library availability - -The header file alsa/topology.h is mandatory and needs to be checked, -too. - -Signed-off-by: Takashi Iwai ---- - utils/alsa.m4 | 1 + - 1 file changed, 1 insertion(+) - -diff --git a/utils/alsa.m4 b/utils/alsa.m4 -index 90e3ee56a981..4c457f0d4e1d 100644 ---- a/utils/alsa.m4 -+++ b/utils/alsa.m4 -@@ -130,6 +130,7 @@ AC_LANG_C - AC_MSG_CHECKING([for libatopology (sound headers version > 1.1.9)]) - AC_TRY_COMPILE([ - #include -+#include - ], [ - /* ensure backward compatibility */ - #if !defined(SND_LIB_VERSION) --- -2.16.4 - diff --git a/0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch b/0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch new file mode 100644 index 0000000..64b6b7d --- /dev/null +++ b/0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch @@ -0,0 +1,38 @@ +From c79f09e1f5e8b559b58dacdb00708d995b2e3aa5 Mon Sep 17 00:00:00 2001 +From: paulhsia +Date: Sat, 30 Nov 2019 03:35:30 +0800 +Subject: [PATCH 01/30] ucm: Use strncmp to avoid access-out-of-boundary + +If the length of the identifier is less than the length of the prefix, +access-out-of-boundary will occur in memcmp(). + +Signed-off-by: paulhsia +Signed-off-by: Jaroslav Kysela +--- + src/ucm/main.c | 8 +++++--- + 1 file changed, 5 insertions(+), 3 deletions(-) + +diff --git a/src/ucm/main.c b/src/ucm/main.c +index b0b6ffb34be5..252e50d9a387 100644 +--- a/src/ucm/main.c ++++ b/src/ucm/main.c +@@ -61,11 +61,13 @@ static int check_identifier(const char *identifier, const char *prefix) + { + int len; + +- if (strcmp(identifier, prefix) == 0) +- return 1; + len = strlen(prefix); +- if (memcmp(identifier, prefix, len) == 0 && identifier[len] == '/') ++ if (strncmp(identifier, prefix, len) != 0) ++ return 0; ++ ++ if (identifier[len] == 0 || identifier[len] == '/') + return 1; ++ + return 0; + } + +-- +2.16.4 + diff --git a/0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch b/0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch new file mode 100644 index 0000000..93fa277 --- /dev/null +++ b/0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch @@ -0,0 +1,42 @@ +From 9baf64da2f26844434ecea4825052937a3abe06c Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 29 Nov 2019 22:28:26 +0100 +Subject: [PATCH 02/30] ucm: return always at least NULL if no list is + available in snd_use_case_get_list() + +Signed-off-by: Jaroslav Kysela +--- + src/ucm/main.c | 8 ++++++-- + 1 file changed, 6 insertions(+), 2 deletions(-) + +diff --git a/src/ucm/main.c b/src/ucm/main.c +index 252e50d9a387..b80db65fa93b 100644 +--- a/src/ucm/main.c ++++ b/src/ucm/main.c +@@ -1160,8 +1160,10 @@ static int get_supcon_device_list(snd_use_case_mgr_t *uc_mgr, + + modifier = find_modifier(uc_mgr, verb, name, 0); + if (modifier) { +- if (modifier->dev_list.type != type) ++ if (modifier->dev_list.type != type) { ++ *list = NULL; + return 0; ++ } + return get_list(&modifier->dev_list.list, list, + struct dev_list_node, list, + name); +@@ -1169,8 +1171,10 @@ static int get_supcon_device_list(snd_use_case_mgr_t *uc_mgr, + + device = find_device(uc_mgr, verb, name, 0); + if (device) { +- if (device->dev_list.type != type) ++ if (device->dev_list.type != type) { ++ *list = NULL; + return 0; ++ } + return get_list(&device->dev_list.list, list, + struct dev_list_node, list, + name); +-- +2.16.4 + diff --git a/0003-ucm-add-_identifiers-list.patch b/0003-ucm-add-_identifiers-list.patch new file mode 100644 index 0000000..0cbfcdd --- /dev/null +++ b/0003-ucm-add-_identifiers-list.patch @@ -0,0 +1,353 @@ +From ebdd2b6cdb8119cf75f0dd0a3b283d271b3a547e Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Sat, 30 Nov 2019 20:31:55 +0100 +Subject: [PATCH 03/30] ucm: add _identifiers list + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 1 + + src/ucm/main.c | 268 +++++++++++++++++++++++++++++++++++++++++------------ + 2 files changed, 208 insertions(+), 61 deletions(-) + +diff --git a/include/use-case.h b/include/use-case.h +index 8e7e838c9cb9..85c58ac0614a 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -206,6 +206,7 @@ int snd_use_case_free_list(const char *list[], int items); + * - _enadevs - get list of enabled devices + * - _enamods - get list of enabled modifiers + * ++ * - _identifiers/{modifier}|{device}[/{verb}] - list of value identifiers + * - _supporteddevs/{modifier}|{device}[/{verb}] - list of supported devices + * - _conflictingdevs/{modifier}|{device}[/{verb}] - list of conflicting devices + * +diff --git a/src/ucm/main.c b/src/ucm/main.c +index b80db65fa93b..d2078a2381d3 100644 +--- a/src/ucm/main.c ++++ b/src/ucm/main.c +@@ -1072,7 +1072,6 @@ int snd_use_case_mgr_reset(snd_use_case_mgr_t *uc_mgr) + /** + * \brief Get list of verbs in pair verbname+comment + * \param list Returned list +- * \param verbname For verb (NULL = current) + * \return Number of list entries if success, otherwise a negative error code + */ + static int get_verb_list(snd_use_case_mgr_t *uc_mgr, const char **list[]) +@@ -1181,7 +1180,6 @@ static int get_supcon_device_list(snd_use_case_mgr_t *uc_mgr, + } + + return -ENOENT; +- + } + + /** +@@ -1210,41 +1208,201 @@ static int get_conflicting_device_list(snd_use_case_mgr_t *uc_mgr, + + #ifndef DOC_HIDDEN + struct myvalue { +- struct list_head list; +- char *value; ++ struct list_head list; ++ const char *text; + }; + #endif + ++/** ++ * \brief Convert myvalue list string list ++ * \param list myvalue list ++ * \param res string list ++ * \retval Number of list entries if success, otherwise a negativer error code ++ */ ++static int myvalue_to_str_list(struct list_head *list, char ***res) ++{ ++ struct list_head *pos; ++ struct myvalue *value; ++ char **p; ++ int cnt; ++ ++ cnt = alloc_str_list(list, 1, res); ++ if (cnt < 0) ++ return cnt; ++ p = *res; ++ list_for_each(pos, list) { ++ value = list_entry(pos, struct myvalue, list); ++ *p = strdup(value->text); ++ if (*p == NULL) { ++ snd_use_case_free_list((const char **)p, cnt); ++ return -ENOMEM; ++ } ++ p++; ++ } ++ return cnt; ++} ++ ++/** ++ * \brief Free myvalue list ++ * \param list myvalue list ++ */ ++static void myvalue_list_free(struct list_head *list) ++{ ++ struct list_head *pos, *npos; ++ struct myvalue *value; ++ ++ list_for_each_safe(pos, npos, list) { ++ value = list_entry(pos, struct myvalue, list); ++ list_del(&value->list); ++ free(value); ++ } ++} ++ ++/** ++ * \brief Merge one value to the myvalue list ++ * \param list The list with values ++ * \param value The value to be merged (without duplicates) ++ * \return 1 if dup, 0 if success, otherwise a negative error code ++ */ ++static int merge_value(struct list_head *list, const char *text) ++{ ++ struct list_head *pos; ++ struct myvalue *value; ++ ++ list_for_each(pos, list) { ++ value = list_entry(pos, struct myvalue, list); ++ if (strcmp(value->text, text) == 0) ++ return 1; ++ } ++ value = malloc(sizeof(*value)); ++ if (value == NULL) ++ return -ENOMEM; ++ value->text = text; ++ list_add_tail(&value->list, list); ++ return 0; ++} ++ ++/** ++ * \brief Find all values for given identifier ++ * \param list Returned list ++ * \param source Source list with ucm_value structures ++ * \return Zero if success, otherwise a negative error code ++ */ ++static int add_identifiers(struct list_head *list, ++ 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); ++ err = merge_value(list, v->name); ++ if (err < 0) ++ return err; ++ } ++ return 0; ++} ++ ++/** ++ * \brief Find all values for given identifier ++ * \param list Returned list ++ * \param identifier Identifier ++ * \param source Source list with ucm_value structures ++ */ + static int add_values(struct list_head *list, + const char *identifier, + struct list_head *source) + { +- struct ucm_value *v; +- struct myvalue *val; +- struct list_head *pos, *pos1; +- int match; ++ 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)) { +- match = 0; +- list_for_each(pos1, list) { +- val = list_entry(pos1, struct myvalue, list); +- if (strcmp(val->value, v->data) == 0) { +- match = 1; +- break; +- } +- } +- if (!match) { +- val = malloc(sizeof(struct myvalue)); +- if (val == NULL) +- return -ENOMEM; +- val->value = v->data; +- list_add_tail(&val->list, list); +- } +- } +- } +- return 0; ++ list_for_each(pos, source) { ++ v = list_entry(pos, struct ucm_value, list); ++ if (check_identifier(identifier, v->name)) { ++ err = merge_value(list, v->data); ++ if (err < 0) ++ return err; ++ } ++ } ++ return 0; ++} ++ ++/** ++ * \brief compare two identifiers ++ */ ++static int identifier_cmp(const void *_a, const void *_b) ++{ ++ const char * const *a = _a; ++ const char * const *b = _b; ++ return strcmp(*a, *b); ++} ++ ++/** ++ * \brief Get list of available identifiers ++ * \param list Returned list ++ * \param name Name of verb or modifier to query ++ * \return Number of list entries if success, otherwise a negative error code ++ */ ++static int get_identifiers_list(snd_use_case_mgr_t *uc_mgr, ++ const char **list[], char *name) ++{ ++ struct use_case_verb *verb; ++ struct use_case_modifier *modifier; ++ struct use_case_device *device; ++ struct list_head mylist; ++ struct list_head *value_list; ++ char *str, **res; ++ int err; ++ ++ if (!name) ++ return -ENOENT; ++ ++ str = strchr(name, '/'); ++ if (str) { ++ *str = '\0'; ++ verb = find_verb(uc_mgr, str + 1); ++ } ++ else { ++ verb = uc_mgr->active_verb; ++ } ++ if (!verb) ++ return -ENOENT; ++ ++ value_list = NULL; ++ modifier = find_modifier(uc_mgr, verb, name, 0); ++ if (modifier) { ++ value_list = &modifier->value_list; ++ } else { ++ device = find_device(uc_mgr, verb, name, 0); ++ if (device) ++ value_list = &device->value_list; ++ } ++ if (value_list == NULL) ++ return -ENOENT; ++ ++ INIT_LIST_HEAD(&mylist); ++ err = add_identifiers(&mylist, &uc_mgr->value_list); ++ if (err < 0) ++ goto __fail; ++ err = add_identifiers(&mylist, &verb->value_list); ++ if (err < 0) ++ goto __fail; ++ err = add_identifiers(&mylist, value_list); ++ if (err < 0) ++ goto __fail; ++ err = myvalue_to_str_list(&mylist, &res); ++ if (err > 0) ++ *list = (const char **)res; ++ else if (err == 0) ++ *list = NULL; ++__fail: ++ myvalue_list_free(&mylist); ++ if (err <= 0) ++ return err; ++ qsort(*list, err, sizeof(char *), identifier_cmp); ++ return err; + } + + /** +@@ -1258,8 +1416,7 @@ static int get_value_list(snd_use_case_mgr_t *uc_mgr, + const char **list[], + char *verbname) + { +- struct list_head mylist, *pos, *npos; +- struct myvalue *val; ++ struct list_head mylist, *pos; + struct use_case_verb *verb; + struct use_case_device *dev; + struct use_case_modifier *mod; +@@ -1292,26 +1449,13 @@ static int get_value_list(snd_use_case_mgr_t *uc_mgr, + if (err < 0) + goto __fail; + } +- err = alloc_str_list(&mylist, 1, &res); +- if (err >= 0) { ++ err = myvalue_to_str_list(&mylist, &res); ++ if (err > 0) + *list = (const char **)res; +- list_for_each(pos, &mylist) { +- val = list_entry(pos, struct myvalue, list); +- *res = strdup(val->value); +- if (*res == NULL) { +- snd_use_case_free_list((const char **)res, err); +- err = -ENOMEM; +- goto __fail; +- } +- res++; +- } +- } ++ else if (err == 0) ++ *list = NULL; + __fail: +- list_for_each_safe(pos, npos, &mylist) { +- val = list_entry(pos, struct myvalue, list); +- list_del(&val->list); +- free(val); +- } ++ myvalue_list_free(&mylist); + return err; + } + +@@ -1381,21 +1525,23 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + } else { + str = NULL; + } +- if (check_identifier(identifier, "_devices")) +- err = get_device_list(uc_mgr, list, str); ++ if (check_identifier(identifier, "_devices")) ++ err = get_device_list(uc_mgr, list, str); + else if (check_identifier(identifier, "_modifiers")) +- err = get_modifier_list(uc_mgr, list, str); +- else if (check_identifier(identifier, "_supporteddevs")) +- err = get_supported_device_list(uc_mgr, list, str); +- else if (check_identifier(identifier, "_conflictingdevs")) +- err = get_conflicting_device_list(uc_mgr, list, str); ++ err = get_modifier_list(uc_mgr, list, str); ++ else if (check_identifier(identifier, "_identifiers")) ++ err = get_identifiers_list(uc_mgr, list, str); ++ else if (check_identifier(identifier, "_supporteddevs")) ++ err = get_supported_device_list(uc_mgr, list, str); ++ else if (check_identifier(identifier, "_conflictingdevs")) ++ err = get_conflicting_device_list(uc_mgr, list, str); + else if (identifier[0] == '_') + err = -ENOENT; +- else +- err = get_value_list(uc_mgr, identifier, list, str); +- if (str) +- free(str); +- } ++ else ++ err = get_value_list(uc_mgr, identifier, list, str); ++ if (str) ++ free(str); ++ } + __end: + pthread_mutex_unlock(&uc_mgr->mutex); + return err; +-- +2.16.4 + diff --git a/0004-namehint-correct-the-args-check.patch b/0004-namehint-correct-the-args-check.patch new file mode 100644 index 0000000..c122b48 --- /dev/null +++ b/0004-namehint-correct-the-args-check.patch @@ -0,0 +1,31 @@ +From 5ee5ef31b5ff3fb7c904054cb9cac7478a727f7c Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Sun, 1 Dec 2019 14:26:40 +0100 +Subject: [PATCH 04/30] namehint: correct the @args check + +BugLink: https://github.com/alsa-project/alsa-plugins/issues/3 +Signed-off-by: Jaroslav Kysela +--- + src/control/namehint.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/src/control/namehint.c b/src/control/namehint.c +index 808df6b50733..4927ef973c32 100644 +--- a/src/control/namehint.c ++++ b/src/control/namehint.c +@@ -348,6 +348,12 @@ static int try_config(snd_config_t *config, + goto __cleanup; + if (snd_config_search(res, "@args", &cfg) >= 0) { + snd_config_for_each(i, next, cfg) { ++ /* skip the argument list */ ++ snd_config_get_id(snd_config_iterator_entry(i), &str); ++ while (*str && *str >= '0' && *str <= '9') str++; ++ if (*str == '\0') ++ continue; ++ /* the argument definition must have the default */ + if (snd_config_search(snd_config_iterator_entry(i), + "default", NULL) < 0) { + err = -EINVAL; +-- +2.16.4 + diff --git a/0005-namehint-improve-the-previous-patch-check-the-return.patch b/0005-namehint-improve-the-previous-patch-check-the-return.patch new file mode 100644 index 0000000..301d66a --- /dev/null +++ b/0005-namehint-improve-the-previous-patch-check-the-return.patch @@ -0,0 +1,28 @@ +From 6055f8a584296abfc0cec0439ceb708f0eddcc9d Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Sun, 1 Dec 2019 14:30:54 +0100 +Subject: [PATCH 05/30] namehint: improve the previous patch (check the + returned value) + +Signed-off-by: Jaroslav Kysela +--- + src/control/namehint.c | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/src/control/namehint.c b/src/control/namehint.c +index 4927ef973c32..60c48ae32877 100644 +--- a/src/control/namehint.c ++++ b/src/control/namehint.c +@@ -349,7 +349,8 @@ static int try_config(snd_config_t *config, + if (snd_config_search(res, "@args", &cfg) >= 0) { + snd_config_for_each(i, next, cfg) { + /* skip the argument list */ +- snd_config_get_id(snd_config_iterator_entry(i), &str); ++ if (snd_config_get_id(snd_config_iterator_entry(i), &str) < 0) ++ continue; + while (*str && *str >= '0' && *str <= '9') str++; + if (*str == '\0') + continue; +-- +2.16.4 + diff --git a/0006-ucm-docs-allow-spaces-in-device-names-for-JackHWMute.patch b/0006-ucm-docs-allow-spaces-in-device-names-for-JackHWMute.patch new file mode 100644 index 0000000..76d3252 --- /dev/null +++ b/0006-ucm-docs-allow-spaces-in-device-names-for-JackHWMute.patch @@ -0,0 +1,56 @@ +From 4dddcf733d56a13f4d042fefa1fb6230c09f1f65 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Mon, 2 Dec 2019 11:56:30 +0100 +Subject: [PATCH 06/30] ucm: docs - allow spaces in device names for JackHWMute + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 25 +++++++++++++------------ + 1 file changed, 13 insertions(+), 12 deletions(-) + +diff --git a/include/use-case.h b/include/use-case.h +index 85c58ac0614a..e1f5802789ff 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -326,7 +326,7 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - Valid values: "soft" (software attenuation) + * - EDIDFile + * - Path to EDID file for HDMI devices +- * - JackControl, JackDev, JackHWMute ++ * - JackControl, JackDev + * - Jack information for a device. The jack status can be reported via + * a kcontrol and/or via an input device. **JackControl** is the + * kcontrol name of the jack, and **JackDev** is the input device id of +@@ -334,17 +334,18 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * JackDev value should be "foo"). UCM configuration files should + * contain both JackControl and JackDev when possible, because + * applications are likely to support only one or the other. +- * +- * If **JackHWMute** is set, it indicates that when the jack is plugged +- * in, the hardware automatically mutes some other device(s). The +- * JackHWMute value is a space-separated list of device names (this +- * isn't compatible with device names with spaces in them, so don't use +- * such device names!). Note that JackHWMute should be used only when +- * the hardware enforces the automatic muting. If the hardware doesn't +- * enforce any muting, it may still be tempting to set JackHWMute to +- * trick upper software layers to e.g. automatically mute speakers when +- * headphones are plugged in, but that's application policy +- * configuration that doesn't belong to UCM configuration files. ++ * - JackHWMute ++ * If this value is set, it indicates that when the jack is plugged ++ * in, the hardware automatically mutes some other device(s). The ++ * value is a space-separated list of device names. If the device ++ * name contains space, it must be enclosed to ' or ", e.g.: ++ * JackHWMute "'Dock Headphone' Headphone" ++ * Note that JackHWMute should be used only when the hardware enforces ++ * the automatic muting. If the hardware doesn't enforce any muting, it ++ * may still be tempting to set JackHWMute to trick upper software layers ++ * to e.g. automatically mute speakers when headphones are plugged in, ++ * but that's application policy configuration that doesn't belong ++ * to UCM configuration files. + * - MinBufferLevel + * - This is used on platform where reported buffer level is not accurate. + * E.g. "512", which holds 512 samples in device buffer. Note: this will +-- +2.16.4 + diff --git a/0007-use-case-docs-add-PlaybackMixerCopy-and-CaptureMixer.patch b/0007-use-case-docs-add-PlaybackMixerCopy-and-CaptureMixer.patch new file mode 100644 index 0000000..1d7e104 --- /dev/null +++ b/0007-use-case-docs-add-PlaybackMixerCopy-and-CaptureMixer.patch @@ -0,0 +1,48 @@ +From 2a286ca9a8415571181ce58027686ec332a834e9 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Mon, 2 Dec 2019 11:57:18 +0100 +Subject: [PATCH 07/30] use-case: docs - add PlaybackMixerCopy and + CaptureMixerCopy + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/include/use-case.h b/include/use-case.h +index e1f5802789ff..71fcc949a117 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -309,8 +309,14 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - PlaybackMixerElem + * - mixer element playback identifier + * - can be parsed using snd_use_case_parse_selem_id() ++ * - PlaybackMixerCopy ++ * - additional mixer element playback identifier ++ * - can be parsed using snd_use_case_parse_selem_id() ++ * - those elements should copy the volume and switch settings ++ * - element identifiers are separated using the | character + * - PlaybackMasterElem + * - mixer element playback identifier for the master control ++ * - can be parsed using snd_use_case_parse_selem_id() + * - PlaybackMasterType + * - type of the master volume control + * - Valid values: "soft" (software attenuation) +@@ -319,8 +325,14 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - CaptureMixerElem + * - mixer element capture identifier + * - can be parsed using snd_use_case_parse_selem_id() ++ * - CaptureMixerCopy ++ * - additional mixer element capture identifier ++ * - can be parsed using snd_use_case_parse_selem_id() ++ * - those elements should copy the volume and switch settings ++ * - element identifiers are separated using the | character + * - CaptureMasterElem + * - mixer element playback identifier for the master control ++ * - can be parsed using snd_use_case_parse_selem_id() + * - CaptureMasterType + * - type of the master volume control + * - Valid values: "soft" (software attenuation) +-- +2.16.4 + diff --git a/0008-ucm-docs-add-JackCTL-rearrange-JackControl-and-JackD.patch b/0008-ucm-docs-add-JackCTL-rearrange-JackControl-and-JackD.patch new file mode 100644 index 0000000..6be1d2d --- /dev/null +++ b/0008-ucm-docs-add-JackCTL-rearrange-JackControl-and-JackD.patch @@ -0,0 +1,47 @@ +From a0fc4447bb7c7f9a850a0a85f3a5a32c1509caf4 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Tue, 3 Dec 2019 15:01:04 +0100 +Subject: [PATCH 08/30] ucm: docs - add JackCTL, rearrange JackControl and + JackDev + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 22 ++++++++++++++-------- + 1 file changed, 14 insertions(+), 8 deletions(-) + +diff --git a/include/use-case.h b/include/use-case.h +index 71fcc949a117..25998cb9bad5 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -338,14 +338,20 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - Valid values: "soft" (software attenuation) + * - EDIDFile + * - Path to EDID file for HDMI devices +- * - JackControl, JackDev +- * - Jack information for a device. The jack status can be reported via +- * a kcontrol and/or via an input device. **JackControl** is the +- * kcontrol name of the jack, and **JackDev** is the input device id of +- * the jack (if the full input device path is /dev/input/by-id/foo, the +- * JackDev value should be "foo"). UCM configuration files should +- * contain both JackControl and JackDev when possible, because +- * applications are likely to support only one or the other. ++ * - JackCTL ++ * - jack control device name ++ * - JackControl ++ * - jack control identificator ++ * - can be parsed using snd_use_case_parse_ctl_elem_id() ++ * - UCM configuration files should contain both JackControl and JackDev ++ * when possible, because applications are likely to support only one ++ * or the other ++ * - JackDev ++ * - the input device id of the jack (if the full input device path is ++ * /dev/input/by-id/foo, the JackDev value should be "foo") ++ * - UCM configuration files should contain both JackControl and JackDev ++ * when possible, because applications are likely to support only one ++ * or the other + * - JackHWMute + * If this value is set, it indicates that when the jack is plugged + * in, the hardware automatically mutes some other device(s). The +-- +2.16.4 + diff --git a/0009-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch b/0009-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch new file mode 100644 index 0000000..2675721 --- /dev/null +++ b/0009-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch @@ -0,0 +1,83 @@ +From e59034a0bec257cc7422a1e9436d936be8696a6f Mon Sep 17 00:00:00 2001 +From: Hans de Goede +Date: Tue, 3 Dec 2019 18:27:39 +0100 +Subject: [PATCH 09/30] ucm: Do not fail to parse configs on cards with an + empty CardComponents lists + +Since the UCM profiles for all Bay- and Cherry-Trail SST cards have been +moved over to UCM2, parsing them fails with: + +ALSA lib ucm_subs.c:220:(uc_mgr_get_substituted_value) variable '${CardComponents}' is not defined in this context! + +This completely breaks audio support on all Bay- and Cherry-Trail devices. + +This is caused by these non-SOF ASoC using cards having an empty +CardComponents list. Which in itself is fine, but is rejected by +the ucm_subs.c code. This commit changes the ucm_subs code to accept +an empty string as a valid value for CardComponents restoring audio +functionality on these boards. + +Signed-off-by: Hans de Goede +Signed-off-by: Jaroslav Kysela +--- + src/ucm/ucm_subs.c | 20 ++++++++++++-------- + 1 file changed, 12 insertions(+), 8 deletions(-) + +diff --git a/src/ucm/ucm_subs.c b/src/ucm/ucm_subs.c +index 00afa9e3de0e..90e395f0ab6f 100644 +--- a/src/ucm/ucm_subs.c ++++ b/src/ucm/ucm_subs.c +@@ -25,6 +25,7 @@ + */ + + #include "ucm_local.h" ++#include + #include + #include + +@@ -145,10 +146,11 @@ static char *rval_sysfs(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED, const char + return strdup(path); + } + +-#define MATCH_VARIABLE(name, id, fcn) \ ++#define MATCH_VARIABLE(name, id, fcn, empty_ok) \ + if (strncmp((name), (id), sizeof(id) - 1) == 0) { \ + rval = fcn(uc_mgr); \ + idsize = sizeof(id) - 1; \ ++ allow_empty = (empty_ok); \ + goto __rval; \ + } + +@@ -189,12 +191,14 @@ int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr, + + while (*value) { + if (*value == '$' && *(value+1) == '{') { +- MATCH_VARIABLE(value, "${ConfName}", rval_conf_name); +- MATCH_VARIABLE(value, "${CardId}", rval_card_id); +- MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver); +- MATCH_VARIABLE(value, "${CardName}", rval_card_name); +- MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname); +- MATCH_VARIABLE(value, "${CardComponents}", rval_card_components); ++ bool allow_empty = false; ++ ++ MATCH_VARIABLE(value, "${ConfName}", rval_conf_name, false); ++ MATCH_VARIABLE(value, "${CardId}", rval_card_id, false); ++ MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver, false); ++ MATCH_VARIABLE(value, "${CardName}", rval_card_name, false); ++ MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname, false); ++ MATCH_VARIABLE(value, "${CardComponents}", rval_card_components, true); + MATCH_VARIABLE2(value, "${env:", rval_env); + MATCH_VARIABLE2(value, "${sys:", rval_sysfs); + err = -EINVAL; +@@ -208,7 +212,7 @@ int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr, + } + goto __error; + __rval: +- if (rval == NULL || rval[0] == '\0') { ++ if (rval == NULL || (!allow_empty && rval[0] == '\0')) { + free(rval); + strncpy(r, value, idsize); + r[idsize] = '\0'; +-- +2.16.4 + diff --git a/0010-src-ucm-main.c-fix-build-without-mixer.patch b/0010-src-ucm-main.c-fix-build-without-mixer.patch new file mode 100644 index 0000000..7271e87 --- /dev/null +++ b/0010-src-ucm-main.c-fix-build-without-mixer.patch @@ -0,0 +1,38 @@ +From 8e2c70add782f997f7c269ed3f722888e56ff024 Mon Sep 17 00:00:00 2001 +From: Fabrice Fontaine +Date: Tue, 3 Dec 2019 18:56:40 +0100 +Subject: [PATCH 10/30] src/ucm/main.c: fix build without mixer + +Commit 4ce38a5ff466d18039b2606938f866ea3a6c9f3c breaks the build without +mixer on: + + CCLD libasound.la +/home/buildroot/autobuild/instance-1/output-1/host/lib/gcc/xtensa-buildroot-linux-uclibc/8.3.0/../../../../xtensa-buildroot-linux-uclibc/bin/ld: ucm/.libs/libucm.a(main.o): in function `snd_use_case_set': +main.c:(.text+0x185c): undefined reference to `snd_mixer_selem_id_parse' + +Fixes: http://autobuild.buildroot.org/results/4d91c9f82a2a61c50c457a851073b85cc09ea345 + +Signed-off-by: Fabrice Fontaine +Signed-off-by: Jaroslav Kysela +--- + src/ucm/main.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/src/ucm/main.c b/src/ucm/main.c +index d2078a2381d3..61922f10b7c7 100644 +--- a/src/ucm/main.c ++++ b/src/ucm/main.c +@@ -2115,8 +2115,10 @@ int snd_use_case_parse_selem_id(snd_mixer_selem_id_t *dst, + const char *ucm_id, + const char *value) + { ++#ifdef BUILD_MIXER + if (strcmp(ucm_id, "PlaybackMixerId") == 0 || + strcmp(ucm_id, "CaptureMixerId") == 0) + return snd_mixer_selem_id_parse(dst, value); ++#endif + return -EINVAL; + } +-- +2.16.4 + diff --git a/0011-alsa.m4-another-try-to-fix-the-libatopology-detectio.patch b/0011-alsa.m4-another-try-to-fix-the-libatopology-detectio.patch new file mode 100644 index 0000000..7ecf963 --- /dev/null +++ b/0011-alsa.m4-another-try-to-fix-the-libatopology-detectio.patch @@ -0,0 +1,53 @@ +From ad8527d81b09c4d0edd054b5b1468ce1c50b23cb Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Wed, 4 Dec 2019 09:49:40 +0100 +Subject: [PATCH 11/30] alsa.m4: another try to fix the libatopology detection + +Signed-off-by: Jaroslav Kysela +--- + utils/alsa.m4 | 11 +++++++++-- + 1 file changed, 9 insertions(+), 2 deletions(-) + +diff --git a/utils/alsa.m4 b/utils/alsa.m4 +index 4c457f0d4e1d..320e4336a925 100644 +--- a/utils/alsa.m4 ++++ b/utils/alsa.m4 +@@ -22,6 +22,7 @@ alsa_save_CFLAGS="$CFLAGS" + alsa_save_LDFLAGS="$LDFLAGS" + alsa_save_LIBS="$LIBS" + alsa_found=yes ++alsa_topology_found=no + + dnl + dnl Get the cflags and libraries for alsa +@@ -158,11 +159,17 @@ AC_CHECK_LIB([asound], [snd_ctl_open],, + alsa_found=no] + ) + if test "x$enable_atopology" = "xyes"; then ++alsa_topology_found=yes + AC_CHECK_LIB([atopology], [snd_tplg_new],, + [ifelse([$3], , [AC_MSG_ERROR(No linkable libatopology was found.)]) +- alsa_found=no] ++ alsa_topology_found=no, ++] + ) + fi ++else ++if test "x$enable_atopology" = "xyes"; then ++ alsa_topology_found=yes ++fi + fi + + if test "x$alsa_found" = "xyes" ; then +@@ -183,7 +190,7 @@ fi + + dnl add the alsa topology library; must be at the end + AC_MSG_CHECKING(for ALSA topology LDFLAGS) +-if test "x$enable_atopology" = "xyes"; then ++if test "x$alsa_topology_found" = "xyes"; then + ALSA_TOPOLOGY_LIBS="$ALSA_TOPOLOGY_LIBS -latopology" + fi + AC_MSG_RESULT($ALSA_TOPOLOGY_LIBS) +-- +2.16.4 + diff --git a/0012-ucm-docs-add-Mic-DigitalMic-and-multiple-devices-com.patch b/0012-ucm-docs-add-Mic-DigitalMic-and-multiple-devices-com.patch new file mode 100644 index 0000000..1bb2c59 --- /dev/null +++ b/0012-ucm-docs-add-Mic-DigitalMic-and-multiple-devices-com.patch @@ -0,0 +1,37 @@ +From 555a5dbdabc5ed3be1ca81865abdb997bc3a6082 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Thu, 5 Dec 2019 16:59:05 +0100 +Subject: [PATCH 12/30] ucm: docs - add Mic/DigitalMic and multiple devices + comments + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 8 ++++++++ + 1 file changed, 8 insertions(+) + +diff --git a/include/use-case.h b/include/use-case.h +index 25998cb9bad5..1736da25b649 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -114,10 +114,18 @@ extern "C" { + * + * Physical system devices the render and capture audio. Devices can be OR'ed + * together to support audio on simultaneous devices. ++ * ++ * If multiple devices with the same name exists, the number suffixes should ++ * be added to these names like HDMI1,HDMI2,HDMI3 etc. No number gaps are ++ * allowed. The names with numbers must be continuous. ++ * ++ * The preference of the devices is determined by the priority value. + */ + #define SND_USE_CASE_DEV_NONE "None" /**< None Device */ + #define SND_USE_CASE_DEV_SPEAKER "Speaker" /**< Speaker Device */ + #define SND_USE_CASE_DEV_LINE "Line" /**< Line Device */ ++#define SND_USE_CASE_DEV_MIC "Mic" /**< Integrated Analog Microphone */ ++#define SND_USE_CASE_DEV_DIGITAL_MIC "DigitalMic" /**< Integrated Digital Microphone */ + #define SND_USE_CASE_DEV_HEADPHONES "Headphones" /**< Headphones Device */ + #define SND_USE_CASE_DEV_HEADSET "Headset" /**< Headset Device */ + #define SND_USE_CASE_DEV_HANDSET "Handset" /**< Handset Device */ +-- +2.16.4 + diff --git a/0013-ucm-docs-remove-DigitalMic-it-does-not-have-sense.patch b/0013-ucm-docs-remove-DigitalMic-it-does-not-have-sense.patch new file mode 100644 index 0000000..1bf849a --- /dev/null +++ b/0013-ucm-docs-remove-DigitalMic-it-does-not-have-sense.patch @@ -0,0 +1,27 @@ +From 1ad660ddeecb2a364f1ca62aa60f256f7029cfdc Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Thu, 5 Dec 2019 17:01:31 +0100 +Subject: [PATCH 13/30] ucm: docs - remove DigitalMic, it does not have sense + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 3 +-- + 1 file changed, 1 insertion(+), 2 deletions(-) + +diff --git a/include/use-case.h b/include/use-case.h +index 1736da25b649..214a2a4c4691 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -124,8 +124,7 @@ extern "C" { + #define SND_USE_CASE_DEV_NONE "None" /**< None Device */ + #define SND_USE_CASE_DEV_SPEAKER "Speaker" /**< Speaker Device */ + #define SND_USE_CASE_DEV_LINE "Line" /**< Line Device */ +-#define SND_USE_CASE_DEV_MIC "Mic" /**< Integrated Analog Microphone */ +-#define SND_USE_CASE_DEV_DIGITAL_MIC "DigitalMic" /**< Integrated Digital Microphone */ ++#define SND_USE_CASE_DEV_MIC "Mic" /**< Integrated Microphone */ + #define SND_USE_CASE_DEV_HEADPHONES "Headphones" /**< Headphones Device */ + #define SND_USE_CASE_DEV_HEADSET "Headset" /**< Headset Device */ + #define SND_USE_CASE_DEV_HANDSET "Handset" /**< Handset Device */ +-- +2.16.4 + diff --git a/0014-ucm-docs-change-the-Mic-description-to-simple-Microp.patch b/0014-ucm-docs-change-the-Mic-description-to-simple-Microp.patch new file mode 100644 index 0000000..e98135d --- /dev/null +++ b/0014-ucm-docs-change-the-Mic-description-to-simple-Microp.patch @@ -0,0 +1,27 @@ +From 5473c5d677915b88d5c93d5bcc6cd16bb6a40342 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Thu, 5 Dec 2019 17:19:06 +0100 +Subject: [PATCH 14/30] ucm: docs - change the Mic description to simple + Microphone Device + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/include/use-case.h b/include/use-case.h +index 214a2a4c4691..b04f7b9d38de 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -124,7 +124,7 @@ extern "C" { + #define SND_USE_CASE_DEV_NONE "None" /**< None Device */ + #define SND_USE_CASE_DEV_SPEAKER "Speaker" /**< Speaker Device */ + #define SND_USE_CASE_DEV_LINE "Line" /**< Line Device */ +-#define SND_USE_CASE_DEV_MIC "Mic" /**< Integrated Microphone */ ++#define SND_USE_CASE_DEV_MIC "Mic" /**< Microphone Device */ + #define SND_USE_CASE_DEV_HEADPHONES "Headphones" /**< Headphones Device */ + #define SND_USE_CASE_DEV_HEADSET "Headset" /**< Headset Device */ + #define SND_USE_CASE_DEV_HANDSET "Handset" /**< Handset Device */ +-- +2.16.4 + diff --git a/0015-ucm-docs-add-note-about-the-sequences-and-device-spl.patch b/0015-ucm-docs-add-note-about-the-sequences-and-device-spl.patch new file mode 100644 index 0000000..36bfc84 --- /dev/null +++ b/0015-ucm-docs-add-note-about-the-sequences-and-device-spl.patch @@ -0,0 +1,30 @@ +From ca67e823833213e140a09ce43b6399b7676616df Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 6 Dec 2019 11:11:54 +0100 +Subject: [PATCH 15/30] ucm: docs - add note about the sequences and device + split + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 5 +++++ + 1 file changed, 5 insertions(+) + +diff --git a/include/use-case.h b/include/use-case.h +index b04f7b9d38de..2efcb4d8fdc3 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -119,6 +119,11 @@ extern "C" { + * be added to these names like HDMI1,HDMI2,HDMI3 etc. No number gaps are + * allowed. The names with numbers must be continuous. + * ++ * If EnableSequence/DisableSequence controls independent paths in the hardware ++ * it is also recommended to split playback and capture UCM devices and use ++ * the number suffixes. Example use case: Use the integrated microphone ++ * in the laptop instead the microphone in headphones. ++ * + * The preference of the devices is determined by the priority value. + */ + #define SND_USE_CASE_DEV_NONE "None" /**< None Device */ +-- +2.16.4 + diff --git a/0016-ucm-docs-remove-MixerCopy-values-add-Priority-for-ve.patch b/0016-ucm-docs-remove-MixerCopy-values-add-Priority-for-ve.patch new file mode 100644 index 0000000..1a7f7db --- /dev/null +++ b/0016-ucm-docs-remove-MixerCopy-values-add-Priority-for-ve.patch @@ -0,0 +1,69 @@ +From f828dfe549fbab0a920768c63ebd3478272954eb Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Tue, 10 Dec 2019 11:48:06 +0100 +Subject: [PATCH 16/30] ucm: docs - remove MixerCopy values, add Priority for + verb, improve priority docs + +Signed-off-by: Jaroslav Kysela +--- + include/use-case.h | 18 ++++++------------ + 1 file changed, 6 insertions(+), 12 deletions(-) + +diff --git a/include/use-case.h b/include/use-case.h +index 2efcb4d8fdc3..134303afaa18 100644 +--- a/include/use-case.h ++++ b/include/use-case.h +@@ -274,6 +274,10 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * Recommended names for values: + * - TQ + * - Tone Quality ++ * - Priority ++ * - priority value (1-10000), higher value means higher priority ++ * - valid only for verbs ++ * - for devices - PlaybackPriority and CapturePriority + * - PlaybackPCM + * - full PCM playback device name + * - PlaybackPCMIsDummy +@@ -301,7 +305,7 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - playback control switch identifier string + * - can be parsed using snd_use_case_parse_ctl_elem_id() + * - PlaybackPriority +- * - priority value (1-10000), default value is 100, higher value means lower priority ++ * - priority value (1-10000), higher value means higher priority + * - CaptureRate + * - capture device sample rate + * - CaptureChannels +@@ -315,17 +319,12 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - capture control switch identifier string + * - can be parsed using snd_use_case_parse_ctl_elem_id() + * - CapturePriority +- * - priority value (1-10000), default value is 100, higher value means lower priority ++ * - priority value (1-10000), higher value means higher priority + * - PlaybackMixer + * - name of playback mixer + * - PlaybackMixerElem + * - mixer element playback identifier + * - can be parsed using snd_use_case_parse_selem_id() +- * - PlaybackMixerCopy +- * - additional mixer element playback identifier +- * - can be parsed using snd_use_case_parse_selem_id() +- * - those elements should copy the volume and switch settings +- * - element identifiers are separated using the | character + * - PlaybackMasterElem + * - mixer element playback identifier for the master control + * - can be parsed using snd_use_case_parse_selem_id() +@@ -337,11 +336,6 @@ int snd_use_case_get_list(snd_use_case_mgr_t *uc_mgr, + * - CaptureMixerElem + * - mixer element capture identifier + * - can be parsed using snd_use_case_parse_selem_id() +- * - CaptureMixerCopy +- * - additional mixer element capture identifier +- * - can be parsed using snd_use_case_parse_selem_id() +- * - those elements should copy the volume and switch settings +- * - element identifiers are separated using the | character + * - CaptureMasterElem + * - mixer element playback identifier for the master control + * - can be parsed using snd_use_case_parse_selem_id() +-- +2.16.4 + diff --git a/0017-ucm-setup-conf_format-after-getting-ALSA_CONFIG_UCM_.patch b/0017-ucm-setup-conf_format-after-getting-ALSA_CONFIG_UCM_.patch new file mode 100644 index 0000000..850b434 --- /dev/null +++ b/0017-ucm-setup-conf_format-after-getting-ALSA_CONFIG_UCM_.patch @@ -0,0 +1,31 @@ +From 1744159180ac94a72036d7232e674c58cedee70a Mon Sep 17 00:00:00 2001 +From: Libin Yang +Date: Wed, 11 Dec 2019 14:07:19 +0800 +Subject: [PATCH 17/30] ucm: setup conf_format after getting + ALSA_CONFIG_UCM_VAR successfully + +Set the conf_format to 1 after getting ALSA_CONFIG_UCM_VAR successfully. +Otherwise, the conf_format is not set in this scenario. + +Signed-off-by: Libin Yang +Signed-off-by: Jaroslav Kysela +--- + src/ucm/parser.c | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/src/ucm/parser.c b/src/ucm/parser.c +index ba5002779f56..d61124a343e1 100644 +--- a/src/ucm/parser.c ++++ b/src/ucm/parser.c +@@ -89,6 +89,8 @@ static void configuration_filename(snd_use_case_mgr_t *uc_mgr, + env = getenv(ALSA_CONFIG_UCM2_VAR); + if (env == NULL) { + env = getenv(ALSA_CONFIG_UCM_VAR); ++ if (env) ++ uc_mgr->conf_format = 1; + } else { + uc_mgr->conf_format = 2; + } +-- +2.16.4 + diff --git a/0018-alsa-lib-fix-the-array-parser-unique-compound-keys.patch b/0018-alsa-lib-fix-the-array-parser-unique-compound-keys.patch new file mode 100644 index 0000000..4dd0516 --- /dev/null +++ b/0018-alsa-lib-fix-the-array-parser-unique-compound-keys.patch @@ -0,0 +1,87 @@ +From 9980e18c3c99da42a90a98b140a0ffe7d0f92cd3 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Thu, 12 Dec 2019 18:42:33 +0100 +Subject: [PATCH 18/30] alsa-lib: fix the array parser (unique compound keys) + +The code from the old import may merge arrays wrongly and +the result is a compound with same keys like: + +Input: + + lines [ + "SSP0.OUT, , BUF1.3" + ] + lines [ + "BUF2.0, , SSP0.IN" + ] + +Parsed contents: + + lines { + 0 'SSP0.OUT, , BUF1.3' + 0 'BUF2.0, , SSP0.IN' + } + +Proper parsed contents (create+merge mode): + + lines { + 0 'SSP0.OUT, , BUF1.3' + 1 'BUF2.0, , SSP0.IN' + } + +Signed-off-by: Jaroslav Kysela +--- + src/conf.c | 20 +++++++++++++++++--- + 1 file changed, 17 insertions(+), 3 deletions(-) + +diff --git a/src/conf.c b/src/conf.c +index e430650430d1..3e753b266b8d 100644 +--- a/src/conf.c ++++ b/src/conf.c +@@ -1226,7 +1226,7 @@ static int parse_value(snd_config_t **_n, snd_config_t *parent, input_t *input, + static int parse_defs(snd_config_t *parent, input_t *input, int skip, int override); + static int parse_array_defs(snd_config_t *farther, input_t *input, int skip, int override); + +-static int parse_array_def(snd_config_t *parent, input_t *input, int idx, int skip, int override) ++static int parse_array_def(snd_config_t *parent, input_t *input, int *idx, int skip, int override) + { + char *id = NULL; + int c; +@@ -1234,8 +1234,21 @@ static int parse_array_def(snd_config_t *parent, input_t *input, int idx, int sk + snd_config_t *n = NULL; + + if (!skip) { ++ snd_config_t *g; + char static_id[12]; +- snprintf(static_id, sizeof(static_id), "%i", idx); ++ while (1) { ++ snprintf(static_id, sizeof(static_id), "%i", *idx); ++ if (_snd_config_search(parent, static_id, -1, &g) == 0) { ++ if (override) { ++ snd_config_delete(n); ++ } else { ++ /* merge */ ++ (*idx)++; ++ continue; ++ } ++ } ++ break; ++ } + id = strdup(static_id); + if (id == NULL) + return -ENOMEM; +@@ -1306,9 +1319,10 @@ static int parse_array_defs(snd_config_t *parent, input_t *input, int skip, int + unget_char(c, input); + if (c == ']') + return 0; +- err = parse_array_def(parent, input, idx++, skip, override); ++ err = parse_array_def(parent, input, &idx, skip, override); + if (err < 0) + return err; ++ idx++; + } + return 0; + } +-- +2.16.4 + diff --git a/0019-topology-remove-vendor_fd-name-from-snd_tplg-structu.patch b/0019-topology-remove-vendor_fd-name-from-snd_tplg-structu.patch new file mode 100644 index 0000000..2420a86 --- /dev/null +++ b/0019-topology-remove-vendor_fd-name-from-snd_tplg-structu.patch @@ -0,0 +1,30 @@ +From 075ee165e647a6b434f63ca578f2f8faff2a55f6 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 16:09:35 +0100 +Subject: [PATCH 19/30] topology: remove vendor_fd/name from snd_tplg structure + - not used + +Signed-off-by: Jaroslav Kysela +--- + src/topology/tplg_local.h | 5 ----- + 1 file changed, 5 deletions(-) + +diff --git a/src/topology/tplg_local.h b/src/topology/tplg_local.h +index c32267d29510..22648fa51f9b 100644 +--- a/src/topology/tplg_local.h ++++ b/src/topology/tplg_local.h +@@ -60,11 +60,6 @@ typedef enum _snd_pcm_rates { + } snd_pcm_rates_t; + + struct snd_tplg { +- +- /* opaque vendor data */ +- int vendor_fd; +- char *vendor_name; +- + /* out file */ + int out_fd; + +-- +2.16.4 + diff --git a/0020-topology-file-position-and-size-cleanups.patch b/0020-topology-file-position-and-size-cleanups.patch new file mode 100644 index 0000000..48962d0 --- /dev/null +++ b/0020-topology-file-position-and-size-cleanups.patch @@ -0,0 +1,319 @@ +From ce74829db630a49569c79aea4aeb288fdd458dd8 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 17:01:03 +0100 +Subject: [PATCH 20/30] topology: file position and size cleanups + +- try to use size_t/ssize_t +- track the position in own variable, do not use lseek + +Signed-off-by: Jaroslav Kysela +--- + src/topology/builder.c | 121 ++++++++++++++++++++++------------------------ + src/topology/tplg_local.h | 3 +- + 2 files changed, 60 insertions(+), 64 deletions(-) + +diff --git a/src/topology/builder.c b/src/topology/builder.c +index 5ae3ae89dac7..4e6cbbb08a1a 100644 +--- a/src/topology/builder.c ++++ b/src/topology/builder.c +@@ -23,28 +23,41 @@ + /* verbose output detailing each object size and file position */ + static void verbose(snd_tplg_t *tplg, const char *fmt, ...) + { +- int offset; + va_list va; + + if (!tplg->verbose) + return; + +- offset = lseek(tplg->out_fd, 0, SEEK_CUR); +- + va_start(va, fmt); +- fprintf(stdout, "0x%6.6x/%6.6d -", offset, offset); ++ fprintf(stdout, "0x%6.6zx/%6.6zd -", tplg->out_pos, tplg->out_pos); + vfprintf(stdout, fmt, va); + va_end(va); + } + ++/* write a block, track the position */ ++static ssize_t twrite(snd_tplg_t *tplg, void *data, size_t data_size) ++{ ++ ssize_t r = write(tplg->out_fd, data, data_size); ++ if (r != (ssize_t)data_size) { ++ if (r < 0) { ++ SNDERR("error: unable to write: %s", strerror(errno)); ++ return -errno; ++ } ++ tplg->out_pos += r; ++ SNDERR("error: unable to write (partial)"); ++ return -EIO; ++ } ++ tplg->out_pos += r; ++ return r; ++} ++ + /* write out block header to output file */ +-static int write_block_header(snd_tplg_t *tplg, unsigned int type, +- unsigned int vendor_type, unsigned int version, unsigned int index, +- size_t payload_size, int count) ++static ssize_t write_block_header(snd_tplg_t *tplg, unsigned int type, ++ unsigned int vendor_type, ++ unsigned int version, unsigned int index, ++ size_t payload_size, int count) + { + struct snd_soc_tplg_hdr hdr; +- size_t bytes; +- int offset = lseek(tplg->out_fd, 0, SEEK_CUR); + + memset(&hdr, 0, sizeof(hdr)); + hdr.magic = SND_SOC_TPLG_MAGIC; +@@ -58,13 +71,13 @@ static int write_block_header(snd_tplg_t *tplg, unsigned int type, + hdr.count = count; + + /* make sure file offset is aligned with the calculated HDR offset */ +- if ((unsigned int)offset != tplg->next_hdr_pos) { +- SNDERR("error: New header is at offset 0x%x but file" +- " offset 0x%x is %s by %d bytes\n", +- tplg->next_hdr_pos, offset, +- (unsigned int)offset > tplg->next_hdr_pos ? "ahead" : "behind", +- abs(offset - tplg->next_hdr_pos)); +- exit(-EINVAL); ++ if (tplg->out_pos != tplg->next_hdr_pos) { ++ SNDERR("error: New header is at offset 0x%zx but file" ++ " offset 0x%zx is %s by %ld bytes\n", ++ tplg->next_hdr_pos, tplg->out_pos, ++ tplg->out_pos > tplg->next_hdr_pos ? "ahead" : "behind", ++ labs(tplg->out_pos - tplg->next_hdr_pos)); ++ return -EINVAL; + } + + verbose(tplg, " header index %d type %d count %d size 0x%lx/%ld vendor %d " +@@ -74,22 +87,16 @@ static int write_block_header(snd_tplg_t *tplg, unsigned int type, + + tplg->next_hdr_pos += hdr.payload_size + sizeof(hdr); + +- bytes = write(tplg->out_fd, &hdr, sizeof(hdr)); +- if (bytes != sizeof(hdr)) { +- SNDERR("error: can't write section header %lu\n", +- (long unsigned int)bytes); +- return bytes; +- } +- +- return bytes; ++ return twrite(tplg, &hdr, sizeof(hdr)); + } + + static int write_elem_block(snd_tplg_t *tplg, +- struct list_head *base, int size, int tplg_type, const char *obj_name) ++ struct list_head *base, size_t size, int tplg_type, const char *obj_name) + { + struct list_head *pos, *sub_pos, *sub_base; + struct tplg_elem *elem, *elem_next; +- int ret, wsize = 0, total_size = 0, count = 0, block_size = 0; ++ size_t total_size = 0, count = 0, block_size = 0; ++ ssize_t ret, wsize; + + sub_base = base; + list_for_each(pos, base) { +@@ -129,12 +136,9 @@ static int write_elem_block(snd_tplg_t *tplg, + elem->route->control, + elem->route->sink, elem->size); + +- wsize = write(tplg->out_fd, elem->obj, elem->size); +- if (wsize < 0) { +- SNDERR("error: failed to write %s %d\n", +- obj_name, ret); +- return ret; +- } ++ wsize = twrite(tplg, elem->obj, elem->size); ++ if (wsize < 0) ++ return size; + + total_size += wsize; + /* get to the end of sub list */ +@@ -151,7 +155,7 @@ static int write_elem_block(snd_tplg_t *tplg, + + /* make sure we have written the correct size */ + if (total_size != size) { +- SNDERR("error: size mismatch. Expected %d wrote %d\n", ++ SNDERR("error: size mismatch. Expected %zu wrote %zu\n", + size, total_size); + return -EIO; + } +@@ -179,8 +183,7 @@ static int calc_block_size(struct list_head *base) + return size; + } + +-static int write_block(snd_tplg_t *tplg, struct list_head *base, +- int type) ++static int write_block(snd_tplg_t *tplg, struct list_head *base, int type) + { + int size; + +@@ -231,44 +234,36 @@ static int write_block(snd_tplg_t *tplg, struct list_head *base, + } + + /* write the manifest including its private data */ +-static int write_manifest_data(snd_tplg_t *tplg) ++static ssize_t write_manifest_data(snd_tplg_t *tplg) + { +- int ret; ++ ssize_t ret; + + /* write the header for this block */ + ret = write_block_header(tplg, SND_SOC_TPLG_TYPE_MANIFEST, 0, + tplg->version, 0, + sizeof(tplg->manifest) + tplg->manifest.priv.size, 1); + if (ret < 0) { +- SNDERR("error: failed to write manifest block %d\n", ret); ++ SNDERR("error: failed to write manifest block\n"); + return ret; + } + + verbose(tplg, "manifest : write %d bytes\n", sizeof(tplg->manifest)); +- ret = write(tplg->out_fd, &tplg->manifest, sizeof(tplg->manifest)); +- if (ret < 0) { +- SNDERR("error: failed to write manifest %d\n", ret); +- return ret; ++ ret = twrite(tplg, &tplg->manifest, sizeof(tplg->manifest)); ++ if (ret >= 0) { ++ verbose(tplg, "manifest : write %d priv bytes\n", tplg->manifest.priv.size); ++ ret = twrite(tplg, tplg->manifest_pdata, tplg->manifest.priv.size); + } +- +- verbose(tplg, "manifest : write %d priv bytes\n", tplg->manifest.priv.size); +- ret = write(tplg->out_fd, tplg->manifest_pdata, tplg->manifest.priv.size); +- if (ret < 0) { +- SNDERR("error: failed to write manifest priv data %d\n", ret); +- return ret; +- } +- +- return 0; ++ return ret; + } + + int tplg_write_data(snd_tplg_t *tplg) + { +- int ret; ++ ssize_t ret; + + /* write manifest */ + ret = write_manifest_data(tplg); + if (ret < 0) { +- SNDERR("failed to write manifest %d\n", ret); ++ SNDERR("failed to write manifest %zd\n", ret); + return ret; + } + +@@ -276,7 +271,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->mixer_list, + SND_TPLG_TYPE_MIXER); + if (ret < 0) { +- SNDERR("failed to write control elems %d\n", ret); ++ SNDERR("failed to write control elems %zd\n", ret); + return ret; + } + +@@ -284,7 +279,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->enum_list, + SND_TPLG_TYPE_ENUM); + if (ret < 0) { +- SNDERR("failed to write control elems %d\n", ret); ++ SNDERR("failed to write control elems %zd\n", ret); + return ret; + } + +@@ -292,7 +287,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->bytes_ext_list, + SND_TPLG_TYPE_BYTES); + if (ret < 0) { +- SNDERR("failed to write control elems %d\n", ret); ++ SNDERR("failed to write control elems %zd\n", ret); + return ret; + } + +@@ -300,7 +295,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->widget_list, + SND_TPLG_TYPE_DAPM_WIDGET); + if (ret < 0) { +- SNDERR("failed to write widget elems %d\n", ret); ++ SNDERR("failed to write widget elems %zd\n", ret); + return ret; + } + +@@ -308,7 +303,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->pcm_list, + SND_TPLG_TYPE_PCM); + if (ret < 0) { +- SNDERR("failed to write pcm elems %d\n", ret); ++ SNDERR("failed to write pcm elems %zd\n", ret); + return ret; + } + +@@ -316,7 +311,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->dai_list, + SND_TPLG_TYPE_DAI); + if (ret < 0) { +- SNDERR("failed to write physical dai elems %d\n", ret); ++ SNDERR("failed to write physical dai elems %zd\n", ret); + return ret; + } + +@@ -324,7 +319,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->be_list, + SND_TPLG_TYPE_BE); + if (ret < 0) { +- SNDERR("failed to write be elems %d\n", ret); ++ SNDERR("failed to write be elems %zd\n", ret); + return ret; + } + +@@ -332,7 +327,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->cc_list, + SND_TPLG_TYPE_CC); + if (ret < 0) { +- SNDERR("failed to write cc elems %d\n", ret); ++ SNDERR("failed to write cc elems %zd\n", ret); + return ret; + } + +@@ -340,7 +335,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->route_list, + SND_TPLG_TYPE_DAPM_GRAPH); + if (ret < 0) { +- SNDERR("failed to write graph elems %d\n", ret); ++ SNDERR("failed to write graph elems %zd\n", ret); + return ret; + } + +@@ -348,7 +343,7 @@ int tplg_write_data(snd_tplg_t *tplg) + ret = write_block(tplg, &tplg->pdata_list, + SND_TPLG_TYPE_DATA); + if (ret < 0) { +- SNDERR("failed to write private data %d\n", ret); ++ SNDERR("failed to write private data %zd\n", ret); + return ret; + } + +diff --git a/src/topology/tplg_local.h b/src/topology/tplg_local.h +index 22648fa51f9b..7b8abcdefbcf 100644 +--- a/src/topology/tplg_local.h ++++ b/src/topology/tplg_local.h +@@ -62,12 +62,13 @@ typedef enum _snd_pcm_rates { + struct snd_tplg { + /* out file */ + int out_fd; ++ size_t out_pos; + + int verbose; + unsigned int version; + + /* runtime state */ +- unsigned int next_hdr_pos; ++ size_t next_hdr_pos; + int index; + int channel_idx; + +-- +2.16.4 + diff --git a/0021-topology-use-an-array-describing-blocks-for-the-main.patch b/0021-topology-use-an-array-describing-blocks-for-the-main.patch new file mode 100644 index 0000000..3a30293 --- /dev/null +++ b/0021-topology-use-an-array-describing-blocks-for-the-main.patch @@ -0,0 +1,179 @@ +From 012bd3b28c0d2744db482caca630d5b0a19e4dab Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 18:24:55 +0100 +Subject: [PATCH 21/30] topology: use an array describing blocks for the main + build loop + +Signed-off-by: Jaroslav Kysela +--- + src/topology/builder.c | 146 +++++++++++++++++++++++-------------------------- + 1 file changed, 67 insertions(+), 79 deletions(-) + +diff --git a/src/topology/builder.c b/src/topology/builder.c +index 4e6cbbb08a1a..ec1af42ddf9b 100644 +--- a/src/topology/builder.c ++++ b/src/topology/builder.c +@@ -258,93 +258,81 @@ static ssize_t write_manifest_data(snd_tplg_t *tplg) + + int tplg_write_data(snd_tplg_t *tplg) + { ++ struct wtable { ++ const char *name; ++ struct list_head *list; ++ int type; ++ } *wptr, wtable[] = { ++ { ++ .name = "control mixer elements", ++ .list = &tplg->mixer_list, ++ .type = SND_TPLG_TYPE_MIXER, ++ }, ++ { ++ .name = "control enum elements", ++ .list = &tplg->enum_list, ++ .type = SND_TPLG_TYPE_ENUM, ++ }, ++ { ++ .name = "control extended (bytes) elements", ++ .list = &tplg->bytes_ext_list, ++ .type = SND_TPLG_TYPE_BYTES, ++ }, ++ { ++ .name = "dapm widget elements", ++ .list = &tplg->widget_list, ++ .type = SND_TPLG_TYPE_DAPM_WIDGET, ++ }, ++ { ++ .name = "pcm elements", ++ .list = &tplg->pcm_list, ++ .type = SND_TPLG_TYPE_PCM, ++ }, ++ { ++ .name = "physical dai elements", ++ .list = &tplg->dai_list, ++ .type = SND_TPLG_TYPE_DAI, ++ }, ++ { ++ .name = "be elements", ++ .list = &tplg->be_list, ++ .type = SND_TPLG_TYPE_BE, ++ }, ++ { ++ .name = "cc elements", ++ .list = &tplg->cc_list, ++ .type = SND_TPLG_TYPE_CC, ++ }, ++ { ++ .name = "route (dapm graph) elements", ++ .list = &tplg->route_list, ++ .type = SND_TPLG_TYPE_DAPM_GRAPH, ++ }, ++ { ++ .name = "private data elements", ++ .list = &tplg->pdata_list, ++ .type = SND_TPLG_TYPE_DATA, ++ }, ++ }; ++ + ssize_t ret; ++ unsigned int index; + + /* write manifest */ + ret = write_manifest_data(tplg); + if (ret < 0) { +- SNDERR("failed to write manifest %zd\n", ret); +- return ret; +- } +- +- /* write mixer elems. */ +- ret = write_block(tplg, &tplg->mixer_list, +- SND_TPLG_TYPE_MIXER); +- if (ret < 0) { +- SNDERR("failed to write control elems %zd\n", ret); +- return ret; +- } +- +- /* write enum control elems. */ +- ret = write_block(tplg, &tplg->enum_list, +- SND_TPLG_TYPE_ENUM); +- if (ret < 0) { +- SNDERR("failed to write control elems %zd\n", ret); +- return ret; +- } +- +- /* write bytes extended control elems. */ +- ret = write_block(tplg, &tplg->bytes_ext_list, +- SND_TPLG_TYPE_BYTES); +- if (ret < 0) { +- SNDERR("failed to write control elems %zd\n", ret); +- return ret; +- } +- +- /* write widget elems */ +- ret = write_block(tplg, &tplg->widget_list, +- SND_TPLG_TYPE_DAPM_WIDGET); +- if (ret < 0) { +- SNDERR("failed to write widget elems %zd\n", ret); +- return ret; +- } +- +- /* write pcm elems */ +- ret = write_block(tplg, &tplg->pcm_list, +- SND_TPLG_TYPE_PCM); +- if (ret < 0) { +- SNDERR("failed to write pcm elems %zd\n", ret); +- return ret; +- } +- +- /* write physical dai elems */ +- ret = write_block(tplg, &tplg->dai_list, +- SND_TPLG_TYPE_DAI); +- if (ret < 0) { +- SNDERR("failed to write physical dai elems %zd\n", ret); +- return ret; +- } +- +- /* write be elems */ +- ret = write_block(tplg, &tplg->be_list, +- SND_TPLG_TYPE_BE); +- if (ret < 0) { +- SNDERR("failed to write be elems %zd\n", ret); +- return ret; +- } +- +- /* write cc elems */ +- ret = write_block(tplg, &tplg->cc_list, +- SND_TPLG_TYPE_CC); +- if (ret < 0) { +- SNDERR("failed to write cc elems %zd\n", ret); +- return ret; +- } +- +- /* write route elems */ +- ret = write_block(tplg, &tplg->route_list, +- SND_TPLG_TYPE_DAPM_GRAPH); +- if (ret < 0) { +- SNDERR("failed to write graph elems %zd\n", ret); ++ SNDERR("failed to write manifest %d\n", ret); + return ret; + } + +- /* write private data */ +- ret = write_block(tplg, &tplg->pdata_list, +- SND_TPLG_TYPE_DATA); +- if (ret < 0) { +- SNDERR("failed to write private data %zd\n", ret); +- return ret; ++ /* write all blocks */ ++ for (index = 0; index < ARRAY_SIZE(wtable); index++) { ++ wptr = &wtable[index]; ++ ret = write_block(tplg, wptr->list, wptr->type); ++ if (ret < 0) { ++ SNDERR("failed to write %s: %s\n", wptr->name, snd_strerror(-ret)); ++ return ret; ++ } + } + + return 0; +-- +2.16.4 + diff --git a/0022-topology-use-size_t-for-calc_block_size.patch b/0022-topology-use-size_t-for-calc_block_size.patch new file mode 100644 index 0000000..a3d34e2 --- /dev/null +++ b/0022-topology-use-size_t-for-calc_block_size.patch @@ -0,0 +1,49 @@ +From f1f5b48d0cfbce0cc6400daba0020d9385d6645e Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 18:26:20 +0100 +Subject: [PATCH 22/30] topology: use size_t for calc_block_size() + +Signed-off-by: Jaroslav Kysela +--- + src/topology/builder.c | 10 +++++----- + 1 file changed, 5 insertions(+), 5 deletions(-) + +diff --git a/src/topology/builder.c b/src/topology/builder.c +index ec1af42ddf9b..bbee71d67e94 100644 +--- a/src/topology/builder.c ++++ b/src/topology/builder.c +@@ -163,11 +163,11 @@ static int write_elem_block(snd_tplg_t *tplg, + return 0; + } + +-static int calc_block_size(struct list_head *base) ++static size_t calc_block_size(struct list_head *base) + { + struct list_head *pos; + struct tplg_elem *elem; +- int size = 0; ++ size_t size = 0; + + list_for_each(pos, base) { + +@@ -185,14 +185,14 @@ static int calc_block_size(struct list_head *base) + + static int write_block(snd_tplg_t *tplg, struct list_head *base, int type) + { +- int size; ++ size_t size; + + /* calculate the block size in bytes for all elems in this list */ + size = calc_block_size(base); +- if (size <= 0) ++ if (size == 0) + return size; + +- verbose(tplg, " block size for type %d is %d\n", type, size); ++ verbose(tplg, " block size for type %d is %zd\n", type, size); + + /* write each elem for this block */ + switch (type) { +-- +2.16.4 + diff --git a/0023-topology-merge-write_block-to-tplg_write_data.patch b/0023-topology-merge-write_block-to-tplg_write_data.patch new file mode 100644 index 0000000..d262308 --- /dev/null +++ b/0023-topology-merge-write_block-to-tplg_write_data.patch @@ -0,0 +1,178 @@ +From 4dcceb5f866deda09e971b1c31d46403c3bd8e9e Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 18:49:29 +0100 +Subject: [PATCH 23/30] topology: merge write_block to tplg_write_data + +Signed-off-by: Jaroslav Kysela +--- + src/topology/builder.c | 95 ++++++++++++++++++-------------------------------- + 1 file changed, 33 insertions(+), 62 deletions(-) + +diff --git a/src/topology/builder.c b/src/topology/builder.c +index bbee71d67e94..f530fcd853c4 100644 +--- a/src/topology/builder.c ++++ b/src/topology/builder.c +@@ -183,56 +183,6 @@ static size_t calc_block_size(struct list_head *base) + return size; + } + +-static int write_block(snd_tplg_t *tplg, struct list_head *base, int type) +-{ +- size_t size; +- +- /* calculate the block size in bytes for all elems in this list */ +- size = calc_block_size(base); +- if (size == 0) +- return size; +- +- verbose(tplg, " block size for type %d is %zd\n", type, size); +- +- /* write each elem for this block */ +- switch (type) { +- case SND_TPLG_TYPE_MIXER: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_MIXER, "mixer"); +- case SND_TPLG_TYPE_BYTES: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_BYTES, "bytes"); +- case SND_TPLG_TYPE_ENUM: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_ENUM, "enum"); +- case SND_TPLG_TYPE_DAPM_GRAPH: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_DAPM_GRAPH, "route"); +- case SND_TPLG_TYPE_DAPM_WIDGET: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_DAPM_WIDGET, "widget"); +- case SND_TPLG_TYPE_PCM: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_PCM, "pcm"); +- case SND_TPLG_TYPE_BE: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_BACKEND_LINK, "be"); +- case SND_TPLG_TYPE_CC: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_CODEC_LINK, "cc"); +- case SND_TPLG_TYPE_DATA: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_PDATA, "data"); +- case SND_TPLG_TYPE_DAI: +- return write_elem_block(tplg, base, size, +- SND_SOC_TPLG_TYPE_DAI, "dai"); +- default: +- return -EINVAL; +- } +- +- return 0; +-} +- + /* write the manifest including its private data */ + static ssize_t write_manifest_data(snd_tplg_t *tplg) + { +@@ -262,60 +212,72 @@ int tplg_write_data(snd_tplg_t *tplg) + const char *name; + struct list_head *list; + int type; ++ int tsoc; + } *wptr, wtable[] = { + { +- .name = "control mixer elements", ++ .name = "control mixer", + .list = &tplg->mixer_list, + .type = SND_TPLG_TYPE_MIXER, ++ .tsoc = SND_SOC_TPLG_TYPE_MIXER, + }, + { +- .name = "control enum elements", ++ .name = "control enum", + .list = &tplg->enum_list, + .type = SND_TPLG_TYPE_ENUM, ++ .tsoc = SND_SOC_TPLG_TYPE_ENUM, + }, + { +- .name = "control extended (bytes) elements", ++ .name = "control extended (bytes)", + .list = &tplg->bytes_ext_list, + .type = SND_TPLG_TYPE_BYTES, ++ .tsoc = SND_SOC_TPLG_TYPE_BYTES, + }, + { +- .name = "dapm widget elements", ++ .name = "dapm widget", + .list = &tplg->widget_list, + .type = SND_TPLG_TYPE_DAPM_WIDGET, ++ .tsoc = SND_SOC_TPLG_TYPE_DAPM_WIDGET, + }, + { +- .name = "pcm elements", ++ .name = "pcm", + .list = &tplg->pcm_list, + .type = SND_TPLG_TYPE_PCM, ++ .tsoc = SND_SOC_TPLG_TYPE_PCM, + }, + { +- .name = "physical dai elements", ++ .name = "physical dai", + .list = &tplg->dai_list, + .type = SND_TPLG_TYPE_DAI, ++ .tsoc = SND_SOC_TPLG_TYPE_DAI, + }, + { +- .name = "be elements", ++ .name = "be", + .list = &tplg->be_list, + .type = SND_TPLG_TYPE_BE, ++ .tsoc = SND_SOC_TPLG_TYPE_BACKEND_LINK, + }, + { +- .name = "cc elements", ++ .name = "cc", + .list = &tplg->cc_list, + .type = SND_TPLG_TYPE_CC, ++ .tsoc = SND_SOC_TPLG_TYPE_CODEC_LINK, + }, + { +- .name = "route (dapm graph) elements", ++ .name = "route (dapm graph)", + .list = &tplg->route_list, + .type = SND_TPLG_TYPE_DAPM_GRAPH, ++ .tsoc = SND_SOC_TPLG_TYPE_DAPM_GRAPH, + }, + { +- .name = "private data elements", ++ .name = "private data", + .list = &tplg->pdata_list, + .type = SND_TPLG_TYPE_DATA, ++ .tsoc = SND_SOC_TPLG_TYPE_PDATA, + }, + }; + + ssize_t ret; ++ size_t size; + unsigned int index; + + /* write manifest */ +@@ -328,9 +290,18 @@ int tplg_write_data(snd_tplg_t *tplg) + /* write all blocks */ + for (index = 0; index < ARRAY_SIZE(wtable); index++) { + wptr = &wtable[index]; +- ret = write_block(tplg, wptr->list, wptr->type); ++ /* calculate the block size in bytes for all elems in this list */ ++ size = calc_block_size(wptr->list); ++ if (size == 0) ++ continue; ++ verbose(tplg, " block size for type %s (%d:%d) is %zd\n", ++ wptr->name, wptr->type, ++ wptr->tsoc, size); ++ ret = write_elem_block(tplg, wptr->list, size, ++ wptr->tsoc, wptr->name); + if (ret < 0) { +- SNDERR("failed to write %s: %s\n", wptr->name, snd_strerror(-ret)); ++ SNDERR("failed to write %s elements: %s\n", ++ wptr->name, snd_strerror(-ret)); + return ret; + } + } +-- +2.16.4 + diff --git a/0024-topology-make-vebose-output-more-nice.patch b/0024-topology-make-vebose-output-more-nice.patch new file mode 100644 index 0000000..d3fd6ff --- /dev/null +++ b/0024-topology-make-vebose-output-more-nice.patch @@ -0,0 +1,81 @@ +From c9e9ee3c40e9f50889f2bb4065c4556184998e8f Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 18:53:41 +0100 +Subject: [PATCH 24/30] topology: make vebose output more nice + +Signed-off-by: Jaroslav Kysela +--- + src/topology/builder.c | 18 ++++++++++-------- + 1 file changed, 10 insertions(+), 8 deletions(-) + +diff --git a/src/topology/builder.c b/src/topology/builder.c +index f530fcd853c4..1a22a453695a 100644 +--- a/src/topology/builder.c ++++ b/src/topology/builder.c +@@ -29,7 +29,7 @@ static void verbose(snd_tplg_t *tplg, const char *fmt, ...) + return; + + va_start(va, fmt); +- fprintf(stdout, "0x%6.6zx/%6.6zd -", tplg->out_pos, tplg->out_pos); ++ fprintf(stdout, "0x%6.6zx/%6.6zd - ", tplg->out_pos, tplg->out_pos); + vfprintf(stdout, fmt, va); + va_end(va); + } +@@ -80,7 +80,7 @@ static ssize_t write_block_header(snd_tplg_t *tplg, unsigned int type, + return -EINVAL; + } + +- verbose(tplg, " header index %d type %d count %d size 0x%lx/%ld vendor %d " ++ verbose(tplg, "header index %d type %d count %d size 0x%lx/%ld vendor %d " + "version %d\n", index, type, count, + (long unsigned int)payload_size, (long int)payload_size, + vendor_type, version); +@@ -128,10 +128,10 @@ static int write_elem_block(snd_tplg_t *tplg, + continue; + + if (elem->type != SND_TPLG_TYPE_DAPM_GRAPH) +- verbose(tplg, " %s '%s': write %d bytes\n", ++ verbose(tplg, "%s '%s': write %d bytes\n", + obj_name, elem->id, elem->size); + else +- verbose(tplg, " %s '%s -> %s -> %s': write %d bytes\n", ++ verbose(tplg, "%s '%s -> %s -> %s': write %d bytes\n", + obj_name, elem->route->source, + elem->route->control, + elem->route->sink, elem->size); +@@ -197,10 +197,10 @@ static ssize_t write_manifest_data(snd_tplg_t *tplg) + return ret; + } + +- verbose(tplg, "manifest : write %d bytes\n", sizeof(tplg->manifest)); ++ verbose(tplg, "manifest: write %d bytes\n", sizeof(tplg->manifest)); + ret = twrite(tplg, &tplg->manifest, sizeof(tplg->manifest)); + if (ret >= 0) { +- verbose(tplg, "manifest : write %d priv bytes\n", tplg->manifest.priv.size); ++ verbose(tplg, "manifest: write %d priv bytes\n", tplg->manifest.priv.size); + ret = twrite(tplg, tplg->manifest_pdata, tplg->manifest.priv.size); + } + return ret; +@@ -294,9 +294,9 @@ int tplg_write_data(snd_tplg_t *tplg) + size = calc_block_size(wptr->list); + if (size == 0) + continue; +- verbose(tplg, " block size for type %s (%d:%d) is %zd\n", ++ verbose(tplg, "block size for type %s (%d:%d) is 0x%zx/%zd\n", + wptr->name, wptr->type, +- wptr->tsoc, size); ++ wptr->tsoc, size, size); + ret = write_elem_block(tplg, wptr->list, size, + wptr->tsoc, wptr->name); + if (ret < 0) { +@@ -306,5 +306,7 @@ int tplg_write_data(snd_tplg_t *tplg) + } + } + ++ verbose(tplg, "total size is 0x%zx/%zd\n", tplg->out_pos, tplg->out_pos); ++ + return 0; + } +-- +2.16.4 + diff --git a/0025-topology-use-list_insert-macro-in-tplg_elem_insert.patch b/0025-topology-use-list_insert-macro-in-tplg_elem_insert.patch new file mode 100644 index 0000000..93a1396 --- /dev/null +++ b/0025-topology-use-list_insert-macro-in-tplg_elem_insert.patch @@ -0,0 +1,39 @@ +From 3b9e39dab5ebfb525b4437a644fe54569e419874 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 21:23:52 +0100 +Subject: [PATCH 25/30] topology: use list_insert() macro in tplg_elem_insert() + +Signed-off-by: Jaroslav Kysela +--- + src/topology/elem.c | 8 +++----- + 1 file changed, 3 insertions(+), 5 deletions(-) + +diff --git a/src/topology/elem.c b/src/topology/elem.c +index a9d1d8547bd2..2066fad83774 100644 +--- a/src/topology/elem.c ++++ b/src/topology/elem.c +@@ -131,7 +131,7 @@ struct tplg_elem *tplg_elem_lookup(struct list_head *base, const char* id, + return NULL; + } + +-/* insert a new element into list in the ascending order of index value*/ ++/* insert a new element into list in the ascending order of index value */ + static void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list) + { + struct list_head *pos, *p = &(elem_p->list); +@@ -142,10 +142,8 @@ static void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list) + if (elem_p->index < elem->index) + break; + } +- p->prev = pos->prev; +- pos->prev->next = p; +- pos->prev = p; +- p->next = pos; ++ /* insert item before pos */ ++ list_insert(p, pos->prev, pos); + } + + /* create a new common element and object */ +-- +2.16.4 + diff --git a/0026-topology-dapm-coding-fixes.patch b/0026-topology-dapm-coding-fixes.patch new file mode 100644 index 0000000..7c22275 --- /dev/null +++ b/0026-topology-dapm-coding-fixes.patch @@ -0,0 +1,81 @@ +From 0d6949b7f1f99bf3fcd5cce78483c10f9ca35264 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 21:52:13 +0100 +Subject: [PATCH 26/30] topology: dapm - coding fixes + +Signed-off-by: Jaroslav Kysela +--- + src/topology/dapm.c | 15 +++++++-------- + 1 file changed, 7 insertions(+), 8 deletions(-) + +diff --git a/src/topology/dapm.c b/src/topology/dapm.c +index 97c9695b9ebe..cd80a4c03d92 100644 +--- a/src/topology/dapm.c ++++ b/src/topology/dapm.c +@@ -152,8 +152,7 @@ static int copy_dapm_control(struct tplg_elem *elem, struct tplg_elem *ref) + } + + /* check referenced controls for a widget */ +-static int tplg_build_widget(snd_tplg_t *tplg, +- struct tplg_elem *elem) ++static int tplg_build_widget(snd_tplg_t *tplg, struct tplg_elem *elem) + { + struct tplg_ref *ref; + struct list_head *base, *pos; +@@ -164,7 +163,7 @@ static int tplg_build_widget(snd_tplg_t *tplg, + /* A widget's private data sits before the embedded controls. + * So merge the private data blocks at first + */ +- list_for_each(pos, base) { ++ list_for_each(pos, base) { + ref = list_entry(pos, struct tplg_ref, list); + + if (ref->type != SND_TPLG_TYPE_DATA) +@@ -314,7 +313,7 @@ int tplg_build_routes(snd_tplg_t *tplg) + return 0; + } + +-struct tplg_elem* tplg_elem_new_route(snd_tplg_t *tplg) ++struct tplg_elem *tplg_elem_new_route(snd_tplg_t *tplg) + { + struct tplg_elem *elem; + struct snd_soc_tplg_dapm_graph_elem *line; +@@ -342,7 +341,7 @@ struct tplg_elem* tplg_elem_new_route(snd_tplg_t *tplg) + + /* line is defined as '"source, control, sink"' */ + static int tplg_parse_line(const char *text, +- struct snd_soc_tplg_dapm_graph_elem *line) ++ struct snd_soc_tplg_dapm_graph_elem *line) + { + char buf[LINE_SIZE]; + unsigned int len, i; +@@ -422,7 +421,7 @@ static int tplg_parse_routes(snd_tplg_t *tplg, snd_config_t *cfg, int index) + } + + int tplg_parse_dapm_graph(snd_tplg_t *tplg, snd_config_t *cfg, +- void *private ATTRIBUTE_UNUSED) ++ void *private ATTRIBUTE_UNUSED) + { + snd_config_iterator_t i, next; + snd_config_t *n; +@@ -472,7 +471,7 @@ int tplg_parse_dapm_graph(snd_tplg_t *tplg, snd_config_t *cfg, + + /* DAPM Widget */ + int tplg_parse_dapm_widget(snd_tplg_t *tplg, +- snd_config_t *cfg, void *private ATTRIBUTE_UNUSED) ++ snd_config_t *cfg, void *private ATTRIBUTE_UNUSED) + { + struct snd_soc_tplg_dapm_widget *widget; + struct tplg_elem *elem; +@@ -645,7 +644,7 @@ int tplg_add_route(snd_tplg_t *tplg, struct snd_tplg_graph_elem *t) + snd_strlcpy(line->source, t->src, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); + if (t->ctl) + snd_strlcpy(line->control, t->ctl, +- SNDRV_CTL_ELEM_ID_NAME_MAXLEN); ++ SNDRV_CTL_ELEM_ID_NAME_MAXLEN); + snd_strlcpy(line->sink, t->sink, SNDRV_CTL_ELEM_ID_NAME_MAXLEN); + + return 0; +-- +2.16.4 + diff --git a/0027-topology-dapm-merge-identical-index-blocks-like-for-.patch b/0027-topology-dapm-merge-identical-index-blocks-like-for-.patch new file mode 100644 index 0000000..5ceda68 --- /dev/null +++ b/0027-topology-dapm-merge-identical-index-blocks-like-for-.patch @@ -0,0 +1,103 @@ +From 2b50b594dcbf69f8dcc6e8cf673748f7063c3c17 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 21:56:58 +0100 +Subject: [PATCH 27/30] topology: dapm - merge identical index blocks like for + other elems + +Signed-off-by: Jaroslav Kysela +--- + src/topology/dapm.c | 14 +++++++------- + src/topology/elem.c | 2 +- + src/topology/tplg_local.h | 1 + + 3 files changed, 9 insertions(+), 8 deletions(-) + +diff --git a/src/topology/dapm.c b/src/topology/dapm.c +index cd80a4c03d92..ce46913192df 100644 +--- a/src/topology/dapm.c ++++ b/src/topology/dapm.c +@@ -313,7 +313,7 @@ int tplg_build_routes(snd_tplg_t *tplg) + return 0; + } + +-struct tplg_elem *tplg_elem_new_route(snd_tplg_t *tplg) ++struct tplg_elem *tplg_elem_new_route(snd_tplg_t *tplg, int index) + { + struct tplg_elem *elem; + struct snd_soc_tplg_dapm_graph_elem *line; +@@ -322,7 +322,8 @@ struct tplg_elem *tplg_elem_new_route(snd_tplg_t *tplg) + if (!elem) + return NULL; + +- list_add_tail(&elem->list, &tplg->route_list); ++ elem->index = index; ++ tplg_elem_insert(elem, &tplg->route_list); + strcpy(elem->id, "line"); + elem->type = SND_TPLG_TYPE_DAPM_GRAPH; + elem->size = sizeof(*line); +@@ -403,10 +404,9 @@ static int tplg_parse_routes(snd_tplg_t *tplg, snd_config_t *cfg, int index) + if (snd_config_get_string(n, &val) < 0) + continue; + +- elem = tplg_elem_new_route(tplg); ++ elem = tplg_elem_new_route(tplg, index); + if (!elem) + return -ENOMEM; +- elem->index = index; + line = elem->route; + + err = tplg_parse_line(val, line); +@@ -628,7 +628,7 @@ int tplg_parse_dapm_widget(snd_tplg_t *tplg, + return 0; + } + +-int tplg_add_route(snd_tplg_t *tplg, struct snd_tplg_graph_elem *t) ++int tplg_add_route(snd_tplg_t *tplg, struct snd_tplg_graph_elem *t, int index) + { + struct tplg_elem *elem; + struct snd_soc_tplg_dapm_graph_elem *line; +@@ -636,7 +636,7 @@ int tplg_add_route(snd_tplg_t *tplg, struct snd_tplg_graph_elem *t) + if (!t->src || !t->sink) + return -EINVAL; + +- elem = tplg_elem_new_route(tplg); ++ elem = tplg_elem_new_route(tplg, index); + if (!elem) + return -ENOMEM; + +@@ -656,7 +656,7 @@ int tplg_add_graph_object(snd_tplg_t *tplg, snd_tplg_obj_template_t *t) + int i, ret; + + for (i = 0; i < gt->count; i++) { +- ret = tplg_add_route(tplg, gt->elem + i); ++ ret = tplg_add_route(tplg, gt->elem + i, t->index); + if (ret < 0) + return ret; + } +diff --git a/src/topology/elem.c b/src/topology/elem.c +index 2066fad83774..140cdd327994 100644 +--- a/src/topology/elem.c ++++ b/src/topology/elem.c +@@ -132,7 +132,7 @@ struct tplg_elem *tplg_elem_lookup(struct list_head *base, const char* id, + } + + /* insert a new element into list in the ascending order of index value */ +-static void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list) ++void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list) + { + struct list_head *pos, *p = &(elem_p->list); + struct tplg_elem *elem; +diff --git a/src/topology/tplg_local.h b/src/topology/tplg_local.h +index 7b8abcdefbcf..11efce6d580c 100644 +--- a/src/topology/tplg_local.h ++++ b/src/topology/tplg_local.h +@@ -273,6 +273,7 @@ int tplg_ref_add_elem(struct tplg_elem *elem, struct tplg_elem *elem_ref); + struct tplg_elem *tplg_elem_new(void); + void tplg_elem_free(struct tplg_elem *elem); + void tplg_elem_free_list(struct list_head *base); ++void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list); + struct tplg_elem *tplg_elem_lookup(struct list_head *base, + const char* id, + unsigned int type, +-- +2.16.4 + diff --git a/0028-topology-more-coding-fixes.patch b/0028-topology-more-coding-fixes.patch new file mode 100644 index 0000000..886457e --- /dev/null +++ b/0028-topology-more-coding-fixes.patch @@ -0,0 +1,228 @@ +From 780f17126aa8d54fc09694cbf652d4135eb731c0 Mon Sep 17 00:00:00 2001 +From: Jaroslav Kysela +Date: Fri, 13 Dec 2019 22:07:46 +0100 +Subject: [PATCH 28/30] topology: more coding fixes + +Signed-off-by: Jaroslav Kysela +--- + src/topology/channel.c | 4 ++-- + src/topology/ctl.c | 15 ++++++++------- + src/topology/elem.c | 6 ++++-- + src/topology/ops.c | 6 +++--- + src/topology/pcm.c | 20 ++++++++++++-------- + src/topology/text.c | 2 +- + 6 files changed, 30 insertions(+), 23 deletions(-) + +diff --git a/src/topology/channel.c b/src/topology/channel.c +index 8516b23f302d..60f7e219a674 100644 +--- a/src/topology/channel.c ++++ b/src/topology/channel.c +@@ -74,8 +74,8 @@ static int lookup_channel(const char *c) + } + + /* Parse a channel mapping. */ +-int tplg_parse_channel(snd_tplg_t *tplg, +- snd_config_t *cfg, void *private) ++int tplg_parse_channel(snd_tplg_t *tplg, snd_config_t *cfg, ++ void *private) + { + snd_config_iterator_t i, next; + snd_config_t *n; +diff --git a/src/topology/ctl.c b/src/topology/ctl.c +index a096252263a5..1db0b16eac95 100644 +--- a/src/topology/ctl.c ++++ b/src/topology/ctl.c +@@ -46,7 +46,7 @@ static const struct ctl_access_elem ctl_access[] = { + + /* find CTL access strings and conver to values */ + static int parse_access_values(snd_config_t *cfg, +- struct snd_soc_tplg_ctl_hdr *hdr) ++ struct snd_soc_tplg_ctl_hdr *hdr) + { + snd_config_iterator_t i, next; + snd_config_t *n; +@@ -77,7 +77,7 @@ static int parse_access_values(snd_config_t *cfg, + + /* Parse Access */ + int parse_access(snd_config_t *cfg, +- struct snd_soc_tplg_ctl_hdr *hdr) ++ struct snd_soc_tplg_ctl_hdr *hdr) + { + snd_config_iterator_t i, next; + snd_config_t *n; +@@ -118,7 +118,7 @@ static int copy_tlv(struct tplg_elem *elem, struct tplg_elem *ref) + + /* check referenced TLV for a mixer control */ + static int tplg_build_mixer_control(snd_tplg_t *tplg, +- struct tplg_elem *elem) ++ struct tplg_elem *elem) + { + struct tplg_ref *ref; + struct list_head *base, *pos; +@@ -157,7 +157,7 @@ static int tplg_build_mixer_control(snd_tplg_t *tplg, + } + + static void copy_enum_texts(struct tplg_elem *enum_elem, +- struct tplg_elem *ref_elem) ++ struct tplg_elem *ref_elem) + { + struct snd_soc_tplg_enum_control *ec = enum_elem->enum_ctrl; + struct tplg_texts *texts = ref_elem->texts; +@@ -169,7 +169,7 @@ static void copy_enum_texts(struct tplg_elem *enum_elem, + + /* check referenced text for a enum control */ + static int tplg_build_enum_control(snd_tplg_t *tplg, +- struct tplg_elem *elem) ++ struct tplg_elem *elem) + { + struct tplg_ref *ref; + struct list_head *base, *pos; +@@ -331,7 +331,7 @@ static int tplg_parse_tlv_dbscale(snd_config_t *cfg, struct tplg_elem *elem) + + /* Parse TLV */ + int tplg_parse_tlv(snd_tplg_t *tplg, snd_config_t *cfg, +- void *private ATTRIBUTE_UNUSED) ++ void *private ATTRIBUTE_UNUSED) + { + snd_config_iterator_t i, next; + snd_config_t *n; +@@ -364,7 +364,8 @@ int tplg_parse_tlv(snd_tplg_t *tplg, snd_config_t *cfg, + + /* Parse Control Bytes */ + int tplg_parse_control_bytes(snd_tplg_t *tplg, +- snd_config_t *cfg, void *private ATTRIBUTE_UNUSED) ++ snd_config_t *cfg, ++ void *private ATTRIBUTE_UNUSED) + { + struct snd_soc_tplg_bytes_control *be; + struct tplg_elem *elem; +diff --git a/src/topology/elem.c b/src/topology/elem.c +index 140cdd327994..d8618cc9d983 100644 +--- a/src/topology/elem.c ++++ b/src/topology/elem.c +@@ -107,7 +107,7 @@ void tplg_elem_free_list(struct list_head *base) + } + + struct tplg_elem *tplg_elem_lookup(struct list_head *base, const char* id, +- unsigned int type, int index) ++ unsigned int type, int index) + { + struct list_head *pos; + struct tplg_elem *elem; +@@ -148,7 +148,9 @@ void tplg_elem_insert(struct tplg_elem *elem_p, struct list_head *list) + + /* create a new common element and object */ + struct tplg_elem* tplg_elem_new_common(snd_tplg_t *tplg, +- snd_config_t *cfg, const char *name, enum snd_tplg_type type) ++ snd_config_t *cfg, ++ const char *name, ++ enum snd_tplg_type type) + { + struct tplg_elem *elem; + const char *id, *val = NULL; +diff --git a/src/topology/ops.c b/src/topology/ops.c +index 6f8dc1ff310f..0f4295a2e50c 100644 +--- a/src/topology/ops.c ++++ b/src/topology/ops.c +@@ -48,8 +48,8 @@ static int lookup_ops(const char *c) + /* Parse Control operations. Ops can come from standard names above or + * bespoke driver controls with numbers >= 256 + */ +-int tplg_parse_ops(snd_tplg_t *tplg ATTRIBUTE_UNUSED, +- snd_config_t *cfg, void *private) ++int tplg_parse_ops(snd_tplg_t *tplg ATTRIBUTE_UNUSED, snd_config_t *cfg, ++ void *private) + { + snd_config_iterator_t i, next; + snd_config_t *n; +@@ -88,7 +88,7 @@ int tplg_parse_ops(snd_tplg_t *tplg ATTRIBUTE_UNUSED, + * bespoke driver controls with numbers >= 256 + */ + int tplg_parse_ext_ops(snd_tplg_t *tplg ATTRIBUTE_UNUSED, +- snd_config_t *cfg, void *private) ++ snd_config_t *cfg, void *private) + { + snd_config_iterator_t i, next; + snd_config_t *n; +diff --git a/src/topology/pcm.c b/src/topology/pcm.c +index 553fd822031b..98a8df979e24 100644 +--- a/src/topology/pcm.c ++++ b/src/topology/pcm.c +@@ -63,7 +63,8 @@ struct tplg_elem *lookup_pcm_dai_stream(struct list_head *base, const char* id) + + /* copy referenced caps to the parent (pcm or be dai) */ + static void copy_stream_caps(const char *id ATTRIBUTE_UNUSED, +- struct snd_soc_tplg_stream_caps *caps, struct tplg_elem *ref_elem) ++ struct snd_soc_tplg_stream_caps *caps, ++ struct tplg_elem *ref_elem) + { + struct snd_soc_tplg_stream_caps *ref_caps = ref_elem->stream_caps; + +@@ -75,7 +76,8 @@ static void copy_stream_caps(const char *id ATTRIBUTE_UNUSED, + + /* find and copy the referenced stream caps */ + static int tplg_build_stream_caps(snd_tplg_t *tplg, +- const char *id, int index, struct snd_soc_tplg_stream_caps *caps) ++ const char *id, int index, ++ struct snd_soc_tplg_stream_caps *caps) + { + struct tplg_elem *ref_elem = NULL; + unsigned int i; +@@ -207,7 +209,8 @@ int tplg_build_dais(snd_tplg_t *tplg, unsigned int type) + } + + static int tplg_build_stream_cfg(snd_tplg_t *tplg, +- struct snd_soc_tplg_stream *stream, int num_streams, int index) ++ struct snd_soc_tplg_stream *stream, ++ int num_streams, int index) + { + struct snd_soc_tplg_stream *strm; + struct tplg_elem *ref_elem; +@@ -367,7 +370,8 @@ static int split_rate(struct snd_soc_tplg_stream_caps *caps, char *str) + + /* Parse pcm stream capabilities */ + int tplg_parse_stream_caps(snd_tplg_t *tplg, +- snd_config_t *cfg, void *private ATTRIBUTE_UNUSED) ++ snd_config_t *cfg, ++ void *private ATTRIBUTE_UNUSED) + { + struct snd_soc_tplg_stream_caps *sc; + struct tplg_elem *elem; +@@ -637,8 +641,8 @@ static int parse_flag(snd_config_t *n, unsigned int mask_in, + } + + /* Parse PCM (for front end DAI & DAI link) in text conf file */ +-int tplg_parse_pcm(snd_tplg_t *tplg, +- snd_config_t *cfg, void *private ATTRIBUTE_UNUSED) ++int tplg_parse_pcm(snd_tplg_t *tplg, snd_config_t *cfg, ++ void *private ATTRIBUTE_UNUSED) + { + struct snd_soc_tplg_pcm *pcm; + struct tplg_elem *elem; +@@ -746,8 +750,8 @@ int tplg_parse_pcm(snd_tplg_t *tplg, + } + + /* Parse physical DAI */ +-int tplg_parse_dai(snd_tplg_t *tplg, +- snd_config_t *cfg, void *private ATTRIBUTE_UNUSED) ++int tplg_parse_dai(snd_tplg_t *tplg, snd_config_t *cfg, ++ void *private ATTRIBUTE_UNUSED) + { + struct snd_soc_tplg_dai *dai; + struct tplg_elem *elem; +diff --git a/src/topology/text.c b/src/topology/text.c +index 72647fe04955..f301a4ded727 100644 +--- a/src/topology/text.c ++++ b/src/topology/text.c +@@ -59,7 +59,7 @@ static int parse_text_values(snd_config_t *cfg, struct tplg_elem *elem) + + /* Parse Text data */ + int tplg_parse_text(snd_tplg_t *tplg, snd_config_t *cfg, +- void *private ATTRIBUTE_UNUSED) ++ void *private ATTRIBUTE_UNUSED) + { + snd_config_iterator_t i, next; + snd_config_t *n; +-- +2.16.4 + diff --git a/0029-Fix-alsa-sound-.h-for-external-programs.patch b/0029-Fix-alsa-sound-.h-for-external-programs.patch new file mode 100644 index 0000000..c4898ec --- /dev/null +++ b/0029-Fix-alsa-sound-.h-for-external-programs.patch @@ -0,0 +1,7099 @@ +From ae564665ec261cf104de499b1cdda3564070fc65 Mon Sep 17 00:00:00 2001 +From: Takashi Iwai +Date: Fri, 20 Dec 2019 15:46:48 +0100 +Subject: [PATCH 29/30] Fix alsa/sound/*.h for external programs + +The recent update of sound/*.h to sync with the latest Linus uapi +files broke the build of alsa-tools programs. These files used to be +a modified version of Linux sound/* header files, so that they could +be built without Linux headers. The special prefix like __user and +other things were worked around there. + +We may do that again, but a better approach is to fix those things in +Linux kernel uapi side, while we keep the minimal workaround in +alsa-lib such as the __u16 and co type definitions. + +This patch is such an attempt, namely: +- Keep the original $LINUX/uapi/sound/*.h in include/sound/uapi + directory +- The "fixes" are applied to some uapi headers, so that they don't + contain Linux-specific prefix and use of opaque struct like + snd_ctl_elem_id +- The uapi headers are included indirectly from include/sound/*.h +- Some headers have inclusion of type_compat.h for the Linux variable + types and prefixes +- type_compat.h tries to use when __linux__ is + defined, instead of the own conflicting definitions + +The last type might need a bit more adjustment depending on the +compiler, but it can be fixed locally without disturbing else. + +Signed-off-by: Takashi Iwai +--- + configure.ac | 3 +- + include/sound/Makefile.am | 6 +- + include/sound/asequencer.h | 613 +--------------------- + include/sound/asoc.h | 634 +--------------------- + include/sound/asound.h | 1039 +------------------------------------ + include/sound/asound_fm.h | 136 +---- + include/sound/emu10k1.h | 383 +------------- + include/sound/hdsp.h | 113 +--- + include/sound/hdspm.h | 234 +-------- + include/sound/sb16_csp.h | 124 +---- + include/sound/sscape_ioctl.h | 22 +- + include/sound/tlv.h | 118 +---- + include/sound/type_compat.h | 13 + + include/sound/uapi/Makefile.am | 6 + + include/sound/uapi/asequencer.h | 612 ++++++++++++++++++++++ + include/sound/uapi/asoc.h | 633 ++++++++++++++++++++++ + include/sound/uapi/asound.h | 1038 ++++++++++++++++++++++++++++++++++++ + include/sound/uapi/asound_fm.h | 135 +++++ + include/sound/uapi/emu10k1.h | 395 ++++++++++++++ + include/sound/uapi/hdsp.h | 109 ++++ + include/sound/uapi/hdspm.h | 230 ++++++++ + include/sound/uapi/sb16_csp.h | 123 +++++ + include/sound/uapi/sscape_ioctl.h | 21 + + include/sound/uapi/tlv.h | 117 +++++ + src/topology/tplg_local.h | 3 +- + 25 files changed, 3452 insertions(+), 3408 deletions(-) + create mode 100644 include/sound/uapi/Makefile.am + create mode 100644 include/sound/uapi/asequencer.h + create mode 100644 include/sound/uapi/asoc.h + create mode 100644 include/sound/uapi/asound.h + create mode 100644 include/sound/uapi/asound_fm.h + create mode 100644 include/sound/uapi/emu10k1.h + create mode 100644 include/sound/uapi/hdsp.h + create mode 100644 include/sound/uapi/hdspm.h + create mode 100644 include/sound/uapi/sb16_csp.h + create mode 100644 include/sound/uapi/sscape_ioctl.h + create mode 100644 include/sound/uapi/tlv.h + +diff --git a/configure.ac b/configure.ac +index 119ef6005103..886f87bc4458 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -707,7 +707,8 @@ if test ! -L "$srcdir"/include/alsa ; then + fi + + AC_OUTPUT(Makefile doc/Makefile doc/pictures/Makefile doc/doxygen.cfg \ +- include/Makefile include/sound/Makefile src/Versions src/Makefile \ ++ include/Makefile include/sound/Makefile include/sound/uapi/Makefile \ ++ src/Versions src/Makefile \ + src/control/Makefile src/mixer/Makefile \ + src/pcm/Makefile src/pcm/scopes/Makefile \ + src/rawmidi/Makefile src/timer/Makefile \ +diff --git a/include/sound/Makefile.am b/include/sound/Makefile.am +index 99c422114535..ccc7d27338cf 100644 +--- a/include/sound/Makefile.am ++++ b/include/sound/Makefile.am +@@ -1,7 +1,9 @@ ++SUBDIRS = uapi ++ + alsasoundincludedir = ${includedir}/alsa/sound + + alsasoundinclude_HEADERS = asound_fm.h hdsp.h hdspm.h sb16_csp.h \ +- sscape_ioctl.h emu10k1.h type_compat.h \ +- asoc.h tlv.h ++ sscape_ioctl.h emu10k1.h asoc.h tlv.h \ ++ type_compat.h + + noinst_HEADERS = asound.h asequencer.h +diff --git a/include/sound/asequencer.h b/include/sound/asequencer.h +index a75e14edc957..e539a77ee764 100644 +--- a/include/sound/asequencer.h ++++ b/include/sound/asequencer.h +@@ -1,612 +1 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-/* +- * Main header file for the ALSA sequencer +- * Copyright (c) 1998-1999 by Frank van de Pol +- * (c) 1998-1999 by Jaroslav Kysela +- * +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +- * +- */ +-#ifndef _UAPI__SOUND_ASEQUENCER_H +-#define _UAPI__SOUND_ASEQUENCER_H +- +-#include +- +-/** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) +- +-/** +- * definition of sequencer event types +- */ +- +-/** system messages +- * event data type = #snd_seq_result +- */ +-#define SNDRV_SEQ_EVENT_SYSTEM 0 +-#define SNDRV_SEQ_EVENT_RESULT 1 +- +-/** note messages (channel specific) +- * event data type = #snd_seq_ev_note +- */ +-#define SNDRV_SEQ_EVENT_NOTE 5 +-#define SNDRV_SEQ_EVENT_NOTEON 6 +-#define SNDRV_SEQ_EVENT_NOTEOFF 7 +-#define SNDRV_SEQ_EVENT_KEYPRESS 8 +- +-/** control messages (channel specific) +- * event data type = #snd_seq_ev_ctrl +- */ +-#define SNDRV_SEQ_EVENT_CONTROLLER 10 +-#define SNDRV_SEQ_EVENT_PGMCHANGE 11 +-#define SNDRV_SEQ_EVENT_CHANPRESS 12 +-#define SNDRV_SEQ_EVENT_PITCHBEND 13 /**< from -8192 to 8191 */ +-#define SNDRV_SEQ_EVENT_CONTROL14 14 /**< 14 bit controller value */ +-#define SNDRV_SEQ_EVENT_NONREGPARAM 15 /**< 14 bit NRPN address + 14 bit unsigned value */ +-#define SNDRV_SEQ_EVENT_REGPARAM 16 /**< 14 bit RPN address + 14 bit unsigned value */ +- +-/** synchronisation messages +- * event data type = #snd_seq_ev_ctrl +- */ +-#define SNDRV_SEQ_EVENT_SONGPOS 20 /* Song Position Pointer with LSB and MSB values */ +-#define SNDRV_SEQ_EVENT_SONGSEL 21 /* Song Select with song ID number */ +-#define SNDRV_SEQ_EVENT_QFRAME 22 /* midi time code quarter frame */ +-#define SNDRV_SEQ_EVENT_TIMESIGN 23 /* SMF Time Signature event */ +-#define SNDRV_SEQ_EVENT_KEYSIGN 24 /* SMF Key Signature event */ +- +-/** timer messages +- * event data type = snd_seq_ev_queue_control +- */ +-#define SNDRV_SEQ_EVENT_START 30 /* midi Real Time Start message */ +-#define SNDRV_SEQ_EVENT_CONTINUE 31 /* midi Real Time Continue message */ +-#define SNDRV_SEQ_EVENT_STOP 32 /* midi Real Time Stop message */ +-#define SNDRV_SEQ_EVENT_SETPOS_TICK 33 /* set tick queue position */ +-#define SNDRV_SEQ_EVENT_SETPOS_TIME 34 /* set realtime queue position */ +-#define SNDRV_SEQ_EVENT_TEMPO 35 /* (SMF) Tempo event */ +-#define SNDRV_SEQ_EVENT_CLOCK 36 /* midi Real Time Clock message */ +-#define SNDRV_SEQ_EVENT_TICK 37 /* midi Real Time Tick message */ +-#define SNDRV_SEQ_EVENT_QUEUE_SKEW 38 /* skew queue tempo */ +- +-/** others +- * event data type = none +- */ +-#define SNDRV_SEQ_EVENT_TUNE_REQUEST 40 /* tune request */ +-#define SNDRV_SEQ_EVENT_RESET 41 /* reset to power-on state */ +-#define SNDRV_SEQ_EVENT_SENSING 42 /* "active sensing" event */ +- +-/** echo back, kernel private messages +- * event data type = any type +- */ +-#define SNDRV_SEQ_EVENT_ECHO 50 /* echo event */ +-#define SNDRV_SEQ_EVENT_OSS 51 /* OSS raw event */ +- +-/** system status messages (broadcast for subscribers) +- * event data type = snd_seq_addr +- */ +-#define SNDRV_SEQ_EVENT_CLIENT_START 60 /* new client has connected */ +-#define SNDRV_SEQ_EVENT_CLIENT_EXIT 61 /* client has left the system */ +-#define SNDRV_SEQ_EVENT_CLIENT_CHANGE 62 /* client status/info has changed */ +-#define SNDRV_SEQ_EVENT_PORT_START 63 /* new port was created */ +-#define SNDRV_SEQ_EVENT_PORT_EXIT 64 /* port was deleted from system */ +-#define SNDRV_SEQ_EVENT_PORT_CHANGE 65 /* port status/info has changed */ +- +-/** port connection changes +- * event data type = snd_seq_connect +- */ +-#define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66 /* ports connected */ +-#define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67 /* ports disconnected */ +- +-/* 70-89: synthesizer events - obsoleted */ +- +-/** user-defined events with fixed length +- * event data type = any +- */ +-#define SNDRV_SEQ_EVENT_USR0 90 +-#define SNDRV_SEQ_EVENT_USR1 91 +-#define SNDRV_SEQ_EVENT_USR2 92 +-#define SNDRV_SEQ_EVENT_USR3 93 +-#define SNDRV_SEQ_EVENT_USR4 94 +-#define SNDRV_SEQ_EVENT_USR5 95 +-#define SNDRV_SEQ_EVENT_USR6 96 +-#define SNDRV_SEQ_EVENT_USR7 97 +-#define SNDRV_SEQ_EVENT_USR8 98 +-#define SNDRV_SEQ_EVENT_USR9 99 +- +-/* 100-118: instrument layer - obsoleted */ +-/* 119-129: reserved */ +- +-/* 130-139: variable length events +- * event data type = snd_seq_ev_ext +- * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set) +- */ +-#define SNDRV_SEQ_EVENT_SYSEX 130 /* system exclusive data (variable length) */ +-#define SNDRV_SEQ_EVENT_BOUNCE 131 /* error event */ +-/* 132-134: reserved */ +-#define SNDRV_SEQ_EVENT_USR_VAR0 135 +-#define SNDRV_SEQ_EVENT_USR_VAR1 136 +-#define SNDRV_SEQ_EVENT_USR_VAR2 137 +-#define SNDRV_SEQ_EVENT_USR_VAR3 138 +-#define SNDRV_SEQ_EVENT_USR_VAR4 139 +- +-/* 150-151: kernel events with quote - DO NOT use in user clients */ +-#define SNDRV_SEQ_EVENT_KERNEL_ERROR 150 +-#define SNDRV_SEQ_EVENT_KERNEL_QUOTE 151 /* obsolete */ +- +-/* 152-191: reserved */ +- +-/* 192-254: hardware specific events */ +- +-/* 255: special event */ +-#define SNDRV_SEQ_EVENT_NONE 255 +- +- +-typedef unsigned char snd_seq_event_type_t; +- +-/** event address */ +-struct snd_seq_addr { +- unsigned char client; /**< Client number: 0..255, 255 = broadcast to all clients */ +- unsigned char port; /**< Port within client: 0..255, 255 = broadcast to all ports */ +-}; +- +-/** port connection */ +-struct snd_seq_connect { +- struct snd_seq_addr sender; +- struct snd_seq_addr dest; +-}; +- +- +-#define SNDRV_SEQ_ADDRESS_UNKNOWN 253 /* unknown source */ +-#define SNDRV_SEQ_ADDRESS_SUBSCRIBERS 254 /* send event to all subscribed ports */ +-#define SNDRV_SEQ_ADDRESS_BROADCAST 255 /* send event to all queues/clients/ports/channels */ +-#define SNDRV_SEQ_QUEUE_DIRECT 253 /* direct dispatch */ +- +- /* event mode flag - NOTE: only 8 bits available! */ +-#define SNDRV_SEQ_TIME_STAMP_TICK (0<<0) /* timestamp in clock ticks */ +-#define SNDRV_SEQ_TIME_STAMP_REAL (1<<0) /* timestamp in real time */ +-#define SNDRV_SEQ_TIME_STAMP_MASK (1<<0) +- +-#define SNDRV_SEQ_TIME_MODE_ABS (0<<1) /* absolute timestamp */ +-#define SNDRV_SEQ_TIME_MODE_REL (1<<1) /* relative to current time */ +-#define SNDRV_SEQ_TIME_MODE_MASK (1<<1) +- +-#define SNDRV_SEQ_EVENT_LENGTH_FIXED (0<<2) /* fixed event size */ +-#define SNDRV_SEQ_EVENT_LENGTH_VARIABLE (1<<2) /* variable event size */ +-#define SNDRV_SEQ_EVENT_LENGTH_VARUSR (2<<2) /* variable event size - user memory space */ +-#define SNDRV_SEQ_EVENT_LENGTH_MASK (3<<2) +- +-#define SNDRV_SEQ_PRIORITY_NORMAL (0<<4) /* normal priority */ +-#define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ +-#define SNDRV_SEQ_PRIORITY_MASK (1<<4) +- +- +- /* note event */ +-struct snd_seq_ev_note { +- unsigned char channel; +- unsigned char note; +- unsigned char velocity; +- unsigned char off_velocity; /* only for SNDRV_SEQ_EVENT_NOTE */ +- unsigned int duration; /* only for SNDRV_SEQ_EVENT_NOTE */ +-}; +- +- /* controller event */ +-struct snd_seq_ev_ctrl { +- unsigned char channel; +- unsigned char unused1, unused2, unused3; /* pad */ +- unsigned int param; +- signed int value; +-}; +- +- /* generic set of bytes (12x8 bit) */ +-struct snd_seq_ev_raw8 { +- unsigned char d[12]; /* 8 bit value */ +-}; +- +- /* generic set of integers (3x32 bit) */ +-struct snd_seq_ev_raw32 { +- unsigned int d[3]; /* 32 bit value */ +-}; +- +- /* external stored data */ +-struct snd_seq_ev_ext { +- unsigned int len; /* length of data */ +- void *ptr; /* pointer to data (note: maybe 64-bit) */ +-} __attribute__((packed)); +- +-struct snd_seq_result { +- int event; /* processed event type */ +- int result; +-}; +- +- +-struct snd_seq_real_time { +- unsigned int tv_sec; /* seconds */ +- unsigned int tv_nsec; /* nanoseconds */ +-}; +- +-typedef unsigned int snd_seq_tick_time_t; /* midi ticks */ +- +-union snd_seq_timestamp { +- snd_seq_tick_time_t tick; +- struct snd_seq_real_time time; +-}; +- +-struct snd_seq_queue_skew { +- unsigned int value; +- unsigned int base; +-}; +- +- /* queue timer control */ +-struct snd_seq_ev_queue_control { +- unsigned char queue; /* affected queue */ +- unsigned char pad[3]; /* reserved */ +- union { +- signed int value; /* affected value (e.g. tempo) */ +- union snd_seq_timestamp time; /* time */ +- unsigned int position; /* sync position */ +- struct snd_seq_queue_skew skew; +- unsigned int d32[2]; +- unsigned char d8[8]; +- } param; +-}; +- +- /* quoted event - inside the kernel only */ +-struct snd_seq_ev_quote { +- struct snd_seq_addr origin; /* original sender */ +- unsigned short value; /* optional data */ +- struct snd_seq_event *event; /* quoted event */ +-} __attribute__((packed)); +- +- +- /* sequencer event */ +-struct snd_seq_event { +- snd_seq_event_type_t type; /* event type */ +- unsigned char flags; /* event flags */ +- char tag; +- +- unsigned char queue; /* schedule queue */ +- union snd_seq_timestamp time; /* schedule time */ +- +- +- struct snd_seq_addr source; /* source address */ +- struct snd_seq_addr dest; /* destination address */ +- +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; +-}; +- +- +-/* +- * bounce event - stored as variable size data +- */ +-struct snd_seq_event_bounce { +- int err; +- struct snd_seq_event event; +- /* external data follows here. */ +-}; +- +- +- /* system information */ +-struct snd_seq_system_info { +- int queues; /* maximum queues count */ +- int clients; /* maximum clients count */ +- int ports; /* maximum ports per client */ +- int channels; /* maximum channels per port */ +- int cur_clients; /* current clients */ +- int cur_queues; /* current queues */ +- char reserved[24]; +-}; +- +- +- /* system running information */ +-struct snd_seq_running_info { +- unsigned char client; /* client id */ +- unsigned char big_endian; /* 1 = big-endian */ +- unsigned char cpu_mode; /* 4 = 32bit, 8 = 64bit */ +- unsigned char pad; /* reserved */ +- unsigned char reserved[12]; +-}; +- +- +- /* known client numbers */ +-#define SNDRV_SEQ_CLIENT_SYSTEM 0 +- /* internal client numbers */ +-#define SNDRV_SEQ_CLIENT_DUMMY 14 /* midi through */ +-#define SNDRV_SEQ_CLIENT_OSS 15 /* oss sequencer emulator */ +- +- +- /* client types */ +-typedef int __bitwise snd_seq_client_type_t; +-#define NO_CLIENT ((__force snd_seq_client_type_t) 0) +-#define USER_CLIENT ((__force snd_seq_client_type_t) 1) +-#define KERNEL_CLIENT ((__force snd_seq_client_type_t) 2) +- +- /* event filter flags */ +-#define SNDRV_SEQ_FILTER_BROADCAST (1<<0) /* accept broadcast messages */ +-#define SNDRV_SEQ_FILTER_MULTICAST (1<<1) /* accept multicast messages */ +-#define SNDRV_SEQ_FILTER_BOUNCE (1<<2) /* accept bounce event in error */ +-#define SNDRV_SEQ_FILTER_USE_EVENT (1<<31) /* use event filter */ +- +-struct snd_seq_client_info { +- int client; /* client number to inquire */ +- snd_seq_client_type_t type; /* client type */ +- char name[64]; /* client name */ +- unsigned int filter; /* filter flags */ +- unsigned char multicast_filter[8]; /* multicast filter bitmap */ +- unsigned char event_filter[32]; /* event filter bitmap */ +- int num_ports; /* RO: number of ports */ +- int event_lost; /* number of lost events */ +- int card; /* RO: card number[kernel] */ +- int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ +-}; +- +- +-/* client pool size */ +-struct snd_seq_client_pool { +- int client; /* client number to inquire */ +- int output_pool; /* outgoing (write) pool size */ +- int input_pool; /* incoming (read) pool size */ +- int output_room; /* minimum free pool size for select/blocking mode */ +- int output_free; /* unused size */ +- int input_free; /* unused size */ +- char reserved[64]; +-}; +- +- +-/* Remove events by specified criteria */ +- +-#define SNDRV_SEQ_REMOVE_INPUT (1<<0) /* Flush input queues */ +-#define SNDRV_SEQ_REMOVE_OUTPUT (1<<1) /* Flush output queues */ +-#define SNDRV_SEQ_REMOVE_DEST (1<<2) /* Restrict by destination q:client:port */ +-#define SNDRV_SEQ_REMOVE_DEST_CHANNEL (1<<3) /* Restrict by channel */ +-#define SNDRV_SEQ_REMOVE_TIME_BEFORE (1<<4) /* Restrict to before time */ +-#define SNDRV_SEQ_REMOVE_TIME_AFTER (1<<5) /* Restrict to time or after */ +-#define SNDRV_SEQ_REMOVE_TIME_TICK (1<<6) /* Time is in ticks */ +-#define SNDRV_SEQ_REMOVE_EVENT_TYPE (1<<7) /* Restrict to event type */ +-#define SNDRV_SEQ_REMOVE_IGNORE_OFF (1<<8) /* Do not flush off events */ +-#define SNDRV_SEQ_REMOVE_TAG_MATCH (1<<9) /* Restrict to events with given tag */ +- +-struct snd_seq_remove_events { +- unsigned int remove_mode; /* Flags that determine what gets removed */ +- +- union snd_seq_timestamp time; +- +- unsigned char queue; /* Queue for REMOVE_DEST */ +- struct snd_seq_addr dest; /* Address for REMOVE_DEST */ +- unsigned char channel; /* Channel for REMOVE_DEST */ +- +- int type; /* For REMOVE_EVENT_TYPE */ +- char tag; /* Tag for REMOVE_TAG */ +- +- int reserved[10]; /* To allow for future binary compatibility */ +- +-}; +- +- +- /* known port numbers */ +-#define SNDRV_SEQ_PORT_SYSTEM_TIMER 0 +-#define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE 1 +- +- /* port capabilities (32 bits) */ +-#define SNDRV_SEQ_PORT_CAP_READ (1<<0) /* readable from this port */ +-#define SNDRV_SEQ_PORT_CAP_WRITE (1<<1) /* writable to this port */ +- +-#define SNDRV_SEQ_PORT_CAP_SYNC_READ (1<<2) +-#define SNDRV_SEQ_PORT_CAP_SYNC_WRITE (1<<3) +- +-#define SNDRV_SEQ_PORT_CAP_DUPLEX (1<<4) +- +-#define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ +-#define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ +-#define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ +- +- /* port type */ +-#define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +-#define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1) /* generic MIDI device */ +-#define SNDRV_SEQ_PORT_TYPE_MIDI_GM (1<<2) /* General MIDI compatible device */ +-#define SNDRV_SEQ_PORT_TYPE_MIDI_GS (1<<3) /* GS compatible device */ +-#define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ +-#define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ +-#define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ +- +-/* other standards...*/ +-#define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +-#define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11) /* Sampling device (support sample download) */ +-#define SNDRV_SEQ_PORT_TYPE_SAMPLE (1<<12) /* Sampling device (sample can be downloaded at any time) */ +-/*...*/ +-#define SNDRV_SEQ_PORT_TYPE_HARDWARE (1<<16) /* driver for a hardware device */ +-#define SNDRV_SEQ_PORT_TYPE_SOFTWARE (1<<17) /* implemented in software */ +-#define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER (1<<18) /* generates sound */ +-#define SNDRV_SEQ_PORT_TYPE_PORT (1<<19) /* connects to other device(s) */ +-#define SNDRV_SEQ_PORT_TYPE_APPLICATION (1<<20) /* application (sequencer/editor) */ +- +-/* misc. conditioning flags */ +-#define SNDRV_SEQ_PORT_FLG_GIVEN_PORT (1<<0) +-#define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) +-#define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) +- +-struct snd_seq_port_info { +- struct snd_seq_addr addr; /* client/port numbers */ +- char name[64]; /* port name */ +- +- unsigned int capability; /* port capability bits */ +- unsigned int type; /* port type bits */ +- int midi_channels; /* channels per MIDI port */ +- int midi_voices; /* voices per MIDI port */ +- int synth_voices; /* voices per SYNTH port */ +- +- int read_use; /* R/O: subscribers for output (from this port) */ +- int write_use; /* R/O: subscribers for input (to this port) */ +- +- void *kernel; /* reserved for kernel use (must be NULL) */ +- unsigned int flags; /* misc. conditioning */ +- unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ +-}; +- +- +-/* queue flags */ +-#define SNDRV_SEQ_QUEUE_FLG_SYNC (1<<0) /* sync enabled */ +- +-/* queue information */ +-struct snd_seq_queue_info { +- int queue; /* queue id */ +- +- /* +- * security settings, only owner of this queue can start/stop timer +- * etc. if the queue is locked for other clients +- */ +- int owner; /* client id for owner of the queue */ +- unsigned locked:1; /* timing queue locked for other queues */ +- char name[64]; /* name of this queue */ +- unsigned int flags; /* flags */ +- char reserved[60]; /* for future use */ +- +-}; +- +-/* queue info/status */ +-struct snd_seq_queue_status { +- int queue; /* queue id */ +- int events; /* read-only - queue size */ +- snd_seq_tick_time_t tick; /* current tick */ +- struct snd_seq_real_time time; /* current time */ +- int running; /* running state of queue */ +- int flags; /* various flags */ +- char reserved[64]; /* for the future */ +-}; +- +- +-/* queue tempo */ +-struct snd_seq_queue_tempo { +- int queue; /* sequencer queue */ +- unsigned int tempo; /* current tempo, us/tick */ +- int ppq; /* time resolution, ticks/quarter */ +- unsigned int skew_value; /* queue skew */ +- unsigned int skew_base; /* queue skew base */ +- char reserved[24]; /* for the future */ +-}; +- +- +-/* sequencer timer sources */ +-#define SNDRV_SEQ_TIMER_ALSA 0 /* ALSA timer */ +-#define SNDRV_SEQ_TIMER_MIDI_CLOCK 1 /* Midi Clock (CLOCK event) */ +-#define SNDRV_SEQ_TIMER_MIDI_TICK 2 /* Midi Timer Tick (TICK event) */ +- +-/* queue timer info */ +-struct snd_seq_queue_timer { +- int queue; /* sequencer queue */ +- int type; /* source timer type */ +- union { +- struct { +- struct snd_timer_id id; /* ALSA's timer ID */ +- unsigned int resolution; /* resolution in Hz */ +- } alsa; +- } u; +- char reserved[64]; /* for the future use */ +-}; +- +- +-struct snd_seq_queue_client { +- int queue; /* sequencer queue */ +- int client; /* sequencer client */ +- int used; /* queue is used with this client +- (must be set for accepting events) */ +- /* per client watermarks */ +- char reserved[64]; /* for future use */ +-}; +- +- +-#define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE (1<<0) /* exclusive connection */ +-#define SNDRV_SEQ_PORT_SUBS_TIMESTAMP (1<<1) +-#define SNDRV_SEQ_PORT_SUBS_TIME_REAL (1<<2) +- +-struct snd_seq_port_subscribe { +- struct snd_seq_addr sender; /* sender address */ +- struct snd_seq_addr dest; /* destination address */ +- unsigned int voices; /* number of voices to be allocated (0 = don't care) */ +- unsigned int flags; /* modes */ +- unsigned char queue; /* input time-stamp queue (optional) */ +- unsigned char pad[3]; /* reserved */ +- char reserved[64]; +-}; +- +-/* type of query subscription */ +-#define SNDRV_SEQ_QUERY_SUBS_READ 0 +-#define SNDRV_SEQ_QUERY_SUBS_WRITE 1 +- +-struct snd_seq_query_subs { +- struct snd_seq_addr root; /* client/port id to be searched */ +- int type; /* READ or WRITE */ +- int index; /* 0..N-1 */ +- int num_subs; /* R/O: number of subscriptions on this port */ +- struct snd_seq_addr addr; /* R/O: result */ +- unsigned char queue; /* R/O: result */ +- unsigned int flags; /* R/O: result */ +- char reserved[64]; /* for future use */ +-}; +- +- +-/* +- * IOCTL commands +- */ +- +-#define SNDRV_SEQ_IOCTL_PVERSION _IOR ('S', 0x00, int) +-#define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) +-#define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) +-#define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) +- +-#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) +-#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) +- +-#define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) +-#define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +-#define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct snd_seq_port_info) +-#define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct snd_seq_port_info) +- +-#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct snd_seq_port_subscribe) +-#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe) +- +-#define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct snd_seq_queue_info) +-#define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct snd_seq_queue_info) +-#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct snd_seq_queue_info) +-#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct snd_seq_queue_info) +-#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info) +-#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status) +-#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo) +-#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo) +-#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer) +-#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer) +-#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct snd_seq_queue_client) +-#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct snd_seq_queue_client) +-#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool) +-#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool) +-#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct snd_seq_remove_events) +-#define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct snd_seq_query_subs) +-#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct snd_seq_port_subscribe) +-#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct snd_seq_client_info) +-#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info) +- +-#endif /* _UAPI__SOUND_ASEQUENCER_H */ ++#include +diff --git a/include/sound/asoc.h b/include/sound/asoc.h +index a74ca232f1fc..185bba810d76 100644 +--- a/include/sound/asoc.h ++++ b/include/sound/asoc.h +@@ -1,633 +1 @@ +-/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ +-/* +- * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM +- * +- * Copyright (C) 2012 Texas Instruments Inc. +- * Copyright (C) 2015 Intel Corporation. +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License version 2 as +- * published by the Free Software Foundation. +- * +- * Simple file API to load FW that includes mixers, coefficients, DAPM graphs, +- * algorithms, equalisers, DAIs, widgets etc. +-*/ +- +-#ifndef __LINUX_UAPI_SND_ASOC_H +-#define __LINUX_UAPI_SND_ASOC_H +- +-#include +-#include +- +-/* +- * Maximum number of channels topology kcontrol can represent. +- */ +-#define SND_SOC_TPLG_MAX_CHAN 8 +- +-/* +- * Maximum number of PCM formats capability +- */ +-#define SND_SOC_TPLG_MAX_FORMATS 16 +- +-/* +- * Maximum number of PCM stream configs +- */ +-#define SND_SOC_TPLG_STREAM_CONFIG_MAX 8 +- +-/* +- * Maximum number of physical link's hardware configs +- */ +-#define SND_SOC_TPLG_HW_CONFIG_MAX 8 +- +-/* individual kcontrol info types - can be mixed with other types */ +-#define SND_SOC_TPLG_CTL_VOLSW 1 +-#define SND_SOC_TPLG_CTL_VOLSW_SX 2 +-#define SND_SOC_TPLG_CTL_VOLSW_XR_SX 3 +-#define SND_SOC_TPLG_CTL_ENUM 4 +-#define SND_SOC_TPLG_CTL_BYTES 5 +-#define SND_SOC_TPLG_CTL_ENUM_VALUE 6 +-#define SND_SOC_TPLG_CTL_RANGE 7 +-#define SND_SOC_TPLG_CTL_STROBE 8 +- +- +-/* individual widget kcontrol info types - can be mixed with other types */ +-#define SND_SOC_TPLG_DAPM_CTL_VOLSW 64 +-#define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE 65 +-#define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT 66 +-#define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE 67 +-#define SND_SOC_TPLG_DAPM_CTL_PIN 68 +- +-/* DAPM widget types - add new items to the end */ +-#define SND_SOC_TPLG_DAPM_INPUT 0 +-#define SND_SOC_TPLG_DAPM_OUTPUT 1 +-#define SND_SOC_TPLG_DAPM_MUX 2 +-#define SND_SOC_TPLG_DAPM_MIXER 3 +-#define SND_SOC_TPLG_DAPM_PGA 4 +-#define SND_SOC_TPLG_DAPM_OUT_DRV 5 +-#define SND_SOC_TPLG_DAPM_ADC 6 +-#define SND_SOC_TPLG_DAPM_DAC 7 +-#define SND_SOC_TPLG_DAPM_SWITCH 8 +-#define SND_SOC_TPLG_DAPM_PRE 9 +-#define SND_SOC_TPLG_DAPM_POST 10 +-#define SND_SOC_TPLG_DAPM_AIF_IN 11 +-#define SND_SOC_TPLG_DAPM_AIF_OUT 12 +-#define SND_SOC_TPLG_DAPM_DAI_IN 13 +-#define SND_SOC_TPLG_DAPM_DAI_OUT 14 +-#define SND_SOC_TPLG_DAPM_DAI_LINK 15 +-#define SND_SOC_TPLG_DAPM_BUFFER 16 +-#define SND_SOC_TPLG_DAPM_SCHEDULER 17 +-#define SND_SOC_TPLG_DAPM_EFFECT 18 +-#define SND_SOC_TPLG_DAPM_SIGGEN 19 +-#define SND_SOC_TPLG_DAPM_SRC 20 +-#define SND_SOC_TPLG_DAPM_ASRC 21 +-#define SND_SOC_TPLG_DAPM_ENCODER 22 +-#define SND_SOC_TPLG_DAPM_DECODER 23 +-#define SND_SOC_TPLG_DAPM_LAST SND_SOC_TPLG_DAPM_DECODER +- +-/* Header magic number and string sizes */ +-#define SND_SOC_TPLG_MAGIC 0x41536F43 /* ASoC */ +- +-/* string sizes */ +-#define SND_SOC_TPLG_NUM_TEXTS 16 +- +-/* ABI version */ +-#define SND_SOC_TPLG_ABI_VERSION 0x5 /* current version */ +-#define SND_SOC_TPLG_ABI_VERSION_MIN 0x4 /* oldest version supported */ +- +-/* Max size of TLV data */ +-#define SND_SOC_TPLG_TLV_SIZE 32 +- +-/* +- * File and Block header data types. +- * Add new generic and vendor types to end of list. +- * Generic types are handled by the core whilst vendors types are passed +- * to the component drivers for handling. +- */ +-#define SND_SOC_TPLG_TYPE_MIXER 1 +-#define SND_SOC_TPLG_TYPE_BYTES 2 +-#define SND_SOC_TPLG_TYPE_ENUM 3 +-#define SND_SOC_TPLG_TYPE_DAPM_GRAPH 4 +-#define SND_SOC_TPLG_TYPE_DAPM_WIDGET 5 +-#define SND_SOC_TPLG_TYPE_DAI_LINK 6 +-#define SND_SOC_TPLG_TYPE_PCM 7 +-#define SND_SOC_TPLG_TYPE_MANIFEST 8 +-#define SND_SOC_TPLG_TYPE_CODEC_LINK 9 +-#define SND_SOC_TPLG_TYPE_BACKEND_LINK 10 +-#define SND_SOC_TPLG_TYPE_PDATA 11 +-#define SND_SOC_TPLG_TYPE_DAI 12 +-#define SND_SOC_TPLG_TYPE_MAX SND_SOC_TPLG_TYPE_DAI +- +-/* vendor block IDs - please add new vendor types to end */ +-#define SND_SOC_TPLG_TYPE_VENDOR_FW 1000 +-#define SND_SOC_TPLG_TYPE_VENDOR_CONFIG 1001 +-#define SND_SOC_TPLG_TYPE_VENDOR_COEFF 1002 +-#define SND_SOC_TPLG_TYPEVENDOR_CODEC 1003 +- +-#define SND_SOC_TPLG_STREAM_PLAYBACK 0 +-#define SND_SOC_TPLG_STREAM_CAPTURE 1 +- +-/* vendor tuple types */ +-#define SND_SOC_TPLG_TUPLE_TYPE_UUID 0 +-#define SND_SOC_TPLG_TUPLE_TYPE_STRING 1 +-#define SND_SOC_TPLG_TUPLE_TYPE_BOOL 2 +-#define SND_SOC_TPLG_TUPLE_TYPE_BYTE 3 +-#define SND_SOC_TPLG_TUPLE_TYPE_WORD 4 +-#define SND_SOC_TPLG_TUPLE_TYPE_SHORT 5 +- +-/* DAI flags */ +-#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES (1 << 0) +-#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) +-#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) +- +-/* DAI clock gating */ +-#define SND_SOC_TPLG_DAI_CLK_GATE_UNDEFINED 0 +-#define SND_SOC_TPLG_DAI_CLK_GATE_GATED 1 +-#define SND_SOC_TPLG_DAI_CLK_GATE_CONT 2 +- +-/* DAI mclk_direction */ +-#define SND_SOC_TPLG_MCLK_CO 0 /* for codec, mclk is output */ +-#define SND_SOC_TPLG_MCLK_CI 1 /* for codec, mclk is input */ +- +-/* DAI physical PCM data formats. +- * Add new formats to the end of the list. +- */ +-#define SND_SOC_DAI_FORMAT_I2S 1 /* I2S mode */ +-#define SND_SOC_DAI_FORMAT_RIGHT_J 2 /* Right Justified mode */ +-#define SND_SOC_DAI_FORMAT_LEFT_J 3 /* Left Justified mode */ +-#define SND_SOC_DAI_FORMAT_DSP_A 4 /* L data MSB after FRM LRC */ +-#define SND_SOC_DAI_FORMAT_DSP_B 5 /* L data MSB during FRM LRC */ +-#define SND_SOC_DAI_FORMAT_AC97 6 /* AC97 */ +-#define SND_SOC_DAI_FORMAT_PDM 7 /* Pulse density modulation */ +- +-/* left and right justified also known as MSB and LSB respectively */ +-#define SND_SOC_DAI_FORMAT_MSB SND_SOC_DAI_FORMAT_LEFT_J +-#define SND_SOC_DAI_FORMAT_LSB SND_SOC_DAI_FORMAT_RIGHT_J +- +-/* DAI link flags */ +-#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES (1 << 0) +-#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) +-#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) +-#define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP (1 << 3) +- +-/* DAI topology BCLK parameter +- * For the backwards capability, by default codec is bclk master +- */ +-#define SND_SOC_TPLG_BCLK_CM 0 /* codec is bclk master */ +-#define SND_SOC_TPLG_BCLK_CS 1 /* codec is bclk slave */ +- +-/* DAI topology FSYNC parameter +- * For the backwards capability, by default codec is fsync master +- */ +-#define SND_SOC_TPLG_FSYNC_CM 0 /* codec is fsync master */ +-#define SND_SOC_TPLG_FSYNC_CS 1 /* codec is fsync slave */ +- +-/* +- * Block Header. +- * This header precedes all object and object arrays below. +- */ +-struct snd_soc_tplg_hdr { +- __le32 magic; /* magic number */ +- __le32 abi; /* ABI version */ +- __le32 version; /* optional vendor specific version details */ +- __le32 type; /* SND_SOC_TPLG_TYPE_ */ +- __le32 size; /* size of this structure */ +- __le32 vendor_type; /* optional vendor specific type info */ +- __le32 payload_size; /* data bytes, excluding this header */ +- __le32 index; /* identifier for block */ +- __le32 count; /* number of elements in block */ +-} __attribute__((packed)); +- +-/* vendor tuple for uuid */ +-struct snd_soc_tplg_vendor_uuid_elem { +- __le32 token; +- char uuid[16]; +-} __attribute__((packed)); +- +-/* vendor tuple for a bool/byte/short/word value */ +-struct snd_soc_tplg_vendor_value_elem { +- __le32 token; +- __le32 value; +-} __attribute__((packed)); +- +-/* vendor tuple for string */ +-struct snd_soc_tplg_vendor_string_elem { +- __le32 token; +- char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +-} __attribute__((packed)); +- +-struct snd_soc_tplg_vendor_array { +- __le32 size; /* size in bytes of the array, including all elements */ +- __le32 type; /* SND_SOC_TPLG_TUPLE_TYPE_ */ +- __le32 num_elems; /* number of elements in array */ +- union { +- struct snd_soc_tplg_vendor_uuid_elem uuid[0]; +- struct snd_soc_tplg_vendor_value_elem value[0]; +- struct snd_soc_tplg_vendor_string_elem string[0]; +- }; +-} __attribute__((packed)); +- +-/* +- * Private data. +- * All topology objects may have private data that can be used by the driver or +- * firmware. Core will ignore this data. +- */ +-struct snd_soc_tplg_private { +- __le32 size; /* in bytes of private data */ +- union { +- char data[0]; +- struct snd_soc_tplg_vendor_array array[0]; +- }; +-} __attribute__((packed)); +- +-/* +- * Kcontrol TLV data. +- */ +-struct snd_soc_tplg_tlv_dbscale { +- __le32 min; +- __le32 step; +- __le32 mute; +-} __attribute__((packed)); +- +-struct snd_soc_tplg_ctl_tlv { +- __le32 size; /* in bytes of this structure */ +- __le32 type; /* SNDRV_CTL_TLVT_*, type of TLV */ +- union { +- __le32 data[SND_SOC_TPLG_TLV_SIZE]; +- struct snd_soc_tplg_tlv_dbscale scale; +- }; +-} __attribute__((packed)); +- +-/* +- * Kcontrol channel data +- */ +-struct snd_soc_tplg_channel { +- __le32 size; /* in bytes of this structure */ +- __le32 reg; +- __le32 shift; +- __le32 id; /* ID maps to Left, Right, LFE etc */ +-} __attribute__((packed)); +- +-/* +- * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops +- * Kcontrol ops need get/put/info. +- * Bytes ext ops need get/put. +- */ +-struct snd_soc_tplg_io_ops { +- __le32 get; +- __le32 put; +- __le32 info; +-} __attribute__((packed)); +- +-/* +- * kcontrol header +- */ +-struct snd_soc_tplg_ctl_hdr { +- __le32 size; /* in bytes of this structure */ +- __le32 type; +- char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- __le32 access; +- struct snd_soc_tplg_io_ops ops; +- struct snd_soc_tplg_ctl_tlv tlv; +-} __attribute__((packed)); +- +-/* +- * Stream Capabilities +- */ +-struct snd_soc_tplg_stream_caps { +- __le32 size; /* in bytes of this structure */ +- char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ +- __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ +- __le32 rate_min; /* min rate */ +- __le32 rate_max; /* max rate */ +- __le32 channels_min; /* min channels */ +- __le32 channels_max; /* max channels */ +- __le32 periods_min; /* min number of periods */ +- __le32 periods_max; /* max number of periods */ +- __le32 period_size_min; /* min period size bytes */ +- __le32 period_size_max; /* max period size bytes */ +- __le32 buffer_size_min; /* min buffer size bytes */ +- __le32 buffer_size_max; /* max buffer size bytes */ +- __le32 sig_bits; /* number of bits of content */ +-} __attribute__((packed)); +- +-/* +- * FE or BE Stream configuration supported by SW/FW +- */ +-struct snd_soc_tplg_stream { +- __le32 size; /* in bytes of this structure */ +- char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* Name of the stream */ +- __le64 format; /* SNDRV_PCM_FMTBIT_* */ +- __le32 rate; /* SNDRV_PCM_RATE_* */ +- __le32 period_bytes; /* size of period in bytes */ +- __le32 buffer_bytes; /* size of buffer in bytes */ +- __le32 channels; /* channels */ +-} __attribute__((packed)); +- +- +-/* +- * Describes a physical link's runtime supported hardware config, +- * i.e. hardware audio formats. +- */ +-struct snd_soc_tplg_hw_config { +- __le32 size; /* in bytes of this structure */ +- __le32 id; /* unique ID - - used to match */ +- __le32 fmt; /* SND_SOC_DAI_FORMAT_ format value */ +- __u8 clock_gated; /* SND_SOC_TPLG_DAI_CLK_GATE_ value */ +- __u8 invert_bclk; /* 1 for inverted BCLK, 0 for normal */ +- __u8 invert_fsync; /* 1 for inverted frame clock, 0 for normal */ +- __u8 bclk_master; /* SND_SOC_TPLG_BCLK_ value */ +- __u8 fsync_master; /* SND_SOC_TPLG_FSYNC_ value */ +- __u8 mclk_direction; /* SND_SOC_TPLG_MCLK_ value */ +- __le16 reserved; /* for 32bit alignment */ +- __le32 mclk_rate; /* MCLK or SYSCLK freqency in Hz */ +- __le32 bclk_rate; /* BCLK freqency in Hz */ +- __le32 fsync_rate; /* frame clock in Hz */ +- __le32 tdm_slots; /* number of TDM slots in use */ +- __le32 tdm_slot_width; /* width in bits for each slot */ +- __le32 tx_slots; /* bit mask for active Tx slots */ +- __le32 rx_slots; /* bit mask for active Rx slots */ +- __le32 tx_channels; /* number of Tx channels */ +- __le32 tx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */ +- __le32 rx_channels; /* number of Rx channels */ +- __le32 rx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */ +-} __attribute__((packed)); +- +-/* +- * Manifest. List totals for each payload type. Not used in parsing, but will +- * be passed to the component driver before any other objects in order for any +- * global component resource allocations. +- * +- * File block representation for manifest :- +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_manifest | 1 | +- * +-----------------------------------+----+ +- */ +-struct snd_soc_tplg_manifest { +- __le32 size; /* in bytes of this structure */ +- __le32 control_elems; /* number of control elements */ +- __le32 widget_elems; /* number of widget elements */ +- __le32 graph_elems; /* number of graph elements */ +- __le32 pcm_elems; /* number of PCM elements */ +- __le32 dai_link_elems; /* number of DAI link elements */ +- __le32 dai_elems; /* number of physical DAI elements */ +- __le32 reserved[20]; /* reserved for new ABI element types */ +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +-/* +- * Mixer kcontrol. +- * +- * File block representation for mixer kcontrol :- +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_mixer_control | N | +- * +-----------------------------------+----+ +- */ +-struct snd_soc_tplg_mixer_control { +- struct snd_soc_tplg_ctl_hdr hdr; +- __le32 size; /* in bytes of this structure */ +- __le32 min; +- __le32 max; +- __le32 platform_max; +- __le32 invert; +- __le32 num_channels; +- struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +-/* +- * Enumerated kcontrol +- * +- * File block representation for enum kcontrol :- +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_enum_control | N | +- * +-----------------------------------+----+ +- */ +-struct snd_soc_tplg_enum_control { +- struct snd_soc_tplg_ctl_hdr hdr; +- __le32 size; /* in bytes of this structure */ +- __le32 num_channels; +- struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; +- __le32 items; +- __le32 mask; +- __le32 count; +- char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- __le32 values[SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4]; +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +-/* +- * Bytes kcontrol +- * +- * File block representation for bytes kcontrol :- +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+----+ +- * | struct snd_soc_tplg_bytes_control | N | +- * +-----------------------------------+----+ +- */ +-struct snd_soc_tplg_bytes_control { +- struct snd_soc_tplg_ctl_hdr hdr; +- __le32 size; /* in bytes of this structure */ +- __le32 max; +- __le32 mask; +- __le32 base; +- __le32 num_regs; +- struct snd_soc_tplg_io_ops ext_ops; +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +-/* +- * DAPM Graph Element +- * +- * File block representation for DAPM graph elements :- +- * +-------------------------------------+----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-------------------------------------+----+ +- * | struct snd_soc_tplg_dapm_graph_elem | N | +- * +-------------------------------------+----+ +- */ +-struct snd_soc_tplg_dapm_graph_elem { +- char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +-} __attribute__((packed)); +- +-/* +- * DAPM Widget. +- * +- * File block representation for DAPM widget :- +- * +-------------------------------------+-----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-------------------------------------+-----+ +- * | struct snd_soc_tplg_dapm_widget | N | +- * +-------------------------------------+-----+ +- * | struct snd_soc_tplg_enum_control | 0|1 | +- * | struct snd_soc_tplg_mixer_control | 0|N | +- * +-------------------------------------+-----+ +- * +- * Optional enum or mixer control can be appended to the end of each widget +- * in the block. +- */ +-struct snd_soc_tplg_dapm_widget { +- __le32 size; /* in bytes of this structure */ +- __le32 id; /* SND_SOC_DAPM_CTL */ +- char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- +- __le32 reg; /* negative reg = no direct dapm */ +- __le32 shift; /* bits to shift */ +- __le32 mask; /* non-shifted mask */ +- __le32 subseq; /* sort within widget type */ +- __le32 invert; /* invert the power bit */ +- __le32 ignore_suspend; /* kept enabled over suspend */ +- __le16 event_flags; +- __le16 event_type; +- __le32 num_kcontrols; +- struct snd_soc_tplg_private priv; +- /* +- * kcontrols that relate to this widget +- * follow here after widget private data +- */ +-} __attribute__((packed)); +- +- +-/* +- * Describes SW/FW specific features of PCM (FE DAI & DAI link). +- * +- * File block representation for PCM :- +- * +-----------------------------------+-----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+-----+ +- * | struct snd_soc_tplg_pcm | N | +- * +-----------------------------------+-----+ +- */ +-struct snd_soc_tplg_pcm { +- __le32 size; /* in bytes of this structure */ +- char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- __le32 pcm_id; /* unique ID - used to match with DAI link */ +- __le32 dai_id; /* unique ID - used to match */ +- __le32 playback; /* supports playback mode */ +- __le32 capture; /* supports capture mode */ +- __le32 compress; /* 1 = compressed; 0 = PCM */ +- struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ +- __le32 num_streams; /* number of streams */ +- struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ +- __le32 flag_mask; /* bitmask of flags to configure */ +- __le32 flags; /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */ +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +- +-/* +- * Describes the physical link runtime supported configs or params +- * +- * File block representation for physical link config :- +- * +-----------------------------------+-----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+-----+ +- * | struct snd_soc_tplg_link_config | N | +- * +-----------------------------------+-----+ +- */ +-struct snd_soc_tplg_link_config { +- __le32 size; /* in bytes of this structure */ +- __le32 id; /* unique ID - used to match */ +- char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ +- char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* stream name - used to match */ +- struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ +- __le32 num_streams; /* number of streams */ +- struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; /* hw configs */ +- __le32 num_hw_configs; /* number of hw configs */ +- __le32 default_hw_config_id; /* default hw config ID for init */ +- __le32 flag_mask; /* bitmask of flags to configure */ +- __le32 flags; /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */ +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +-/* +- * Describes SW/FW specific features of physical DAI. +- * It can be used to configure backend DAIs for DPCM. +- * +- * File block representation for physical DAI :- +- * +-----------------------------------+-----+ +- * | struct snd_soc_tplg_hdr | 1 | +- * +-----------------------------------+-----+ +- * | struct snd_soc_tplg_dai | N | +- * +-----------------------------------+-----+ +- */ +-struct snd_soc_tplg_dai { +- __le32 size; /* in bytes of this structure */ +- char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ +- __le32 dai_id; /* unique ID - used to match */ +- __le32 playback; /* supports playback mode */ +- __le32 capture; /* supports capture mode */ +- struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ +- __le32 flag_mask; /* bitmask of flags to configure */ +- __le32 flags; /* SND_SOC_TPLG_DAI_FLGBIT_* */ +- struct snd_soc_tplg_private priv; +-} __attribute__((packed)); +- +-/* +- * Old version of ABI structs, supported for backward compatibility. +- */ +- +-/* Manifest v4 */ +-struct snd_soc_tplg_manifest_v4 { +- __le32 size; /* in bytes of this structure */ +- __le32 control_elems; /* number of control elements */ +- __le32 widget_elems; /* number of widget elements */ +- __le32 graph_elems; /* number of graph elements */ +- __le32 pcm_elems; /* number of PCM elements */ +- __le32 dai_link_elems; /* number of DAI link elements */ +- struct snd_soc_tplg_private priv; +-} __packed; +- +-/* Stream Capabilities v4 */ +-struct snd_soc_tplg_stream_caps_v4 { +- __le32 size; /* in bytes of this structure */ +- char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ +- __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ +- __le32 rate_min; /* min rate */ +- __le32 rate_max; /* max rate */ +- __le32 channels_min; /* min channels */ +- __le32 channels_max; /* max channels */ +- __le32 periods_min; /* min number of periods */ +- __le32 periods_max; /* max number of periods */ +- __le32 period_size_min; /* min period size bytes */ +- __le32 period_size_max; /* max period size bytes */ +- __le32 buffer_size_min; /* min buffer size bytes */ +- __le32 buffer_size_max; /* max buffer size bytes */ +-} __packed; +- +-/* PCM v4 */ +-struct snd_soc_tplg_pcm_v4 { +- __le32 size; /* in bytes of this structure */ +- char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; +- __le32 pcm_id; /* unique ID - used to match with DAI link */ +- __le32 dai_id; /* unique ID - used to match */ +- __le32 playback; /* supports playback mode */ +- __le32 capture; /* supports capture mode */ +- __le32 compress; /* 1 = compressed; 0 = PCM */ +- struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ +- __le32 num_streams; /* number of streams */ +- struct snd_soc_tplg_stream_caps_v4 caps[2]; /* playback and capture for DAI */ +-} __packed; +- +-/* Physical link config v4 */ +-struct snd_soc_tplg_link_config_v4 { +- __le32 size; /* in bytes of this structure */ +- __le32 id; /* unique ID - used to match */ +- struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ +- __le32 num_streams; /* number of streams */ +-} __packed; +- +-#endif ++#include +diff --git a/include/sound/asound.h b/include/sound/asound.h +index df1153cea0b7..3be4d850a073 100644 +--- a/include/sound/asound.h ++++ b/include/sound/asound.h +@@ -1,1038 +1 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-/* +- * Advanced Linux Sound Architecture - ALSA - Driver +- * Copyright (c) 1994-2003 by Jaroslav Kysela , +- * Abramo Bagnara +- * +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +- * +- */ +- +-#ifndef _UAPI__SOUND_ASOUND_H +-#define _UAPI__SOUND_ASOUND_H +- +-#if defined(__KERNEL__) || defined(__linux__) +-#include +-#else +-#include +-#endif +- +-#ifndef __KERNEL__ +-#include +-#include +-#endif +- +-/* +- * protocol version +- */ +- +-#define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor)) +-#define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff) +-#define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff) +-#define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff) +-#define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \ +- (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \ +- (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \ +- SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion))) +- +-/**************************************************************************** +- * * +- * Digital audio interface * +- * * +- ****************************************************************************/ +- +-struct snd_aes_iec958 { +- unsigned char status[24]; /* AES/IEC958 channel status bits */ +- unsigned char subcode[147]; /* AES/IEC958 subcode bits */ +- unsigned char pad; /* nothing */ +- unsigned char dig_subframe[4]; /* AES/IEC958 subframe bits */ +-}; +- +-/**************************************************************************** +- * * +- * CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort * +- * * +- ****************************************************************************/ +- +-struct snd_cea_861_aud_if { +- unsigned char db1_ct_cc; /* coding type and channel count */ +- unsigned char db2_sf_ss; /* sample frequency and size */ +- unsigned char db3; /* not used, all zeros */ +- unsigned char db4_ca; /* channel allocation code */ +- unsigned char db5_dminh_lsv; /* downmix inhibit & level-shit values */ +-}; +- +-/**************************************************************************** +- * * +- * Section for driver hardware dependent interface - /dev/snd/hw? * +- * * +- ****************************************************************************/ +- +-#define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) +- +-enum { +- SNDRV_HWDEP_IFACE_OPL2 = 0, +- SNDRV_HWDEP_IFACE_OPL3, +- SNDRV_HWDEP_IFACE_OPL4, +- SNDRV_HWDEP_IFACE_SB16CSP, /* Creative Signal Processor */ +- SNDRV_HWDEP_IFACE_EMU10K1, /* FX8010 processor in EMU10K1 chip */ +- SNDRV_HWDEP_IFACE_YSS225, /* Yamaha FX processor */ +- SNDRV_HWDEP_IFACE_ICS2115, /* Wavetable synth */ +- SNDRV_HWDEP_IFACE_SSCAPE, /* Ensoniq SoundScape ISA card (MC68EC000) */ +- SNDRV_HWDEP_IFACE_VX, /* Digigram VX cards */ +- SNDRV_HWDEP_IFACE_MIXART, /* Digigram miXart cards */ +- SNDRV_HWDEP_IFACE_USX2Y, /* Tascam US122, US224 & US428 usb */ +- SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */ +- SNDRV_HWDEP_IFACE_BLUETOOTH, /* Bluetooth audio */ +- SNDRV_HWDEP_IFACE_USX2Y_PCM, /* Tascam US122, US224 & US428 rawusb pcm */ +- SNDRV_HWDEP_IFACE_PCXHR, /* Digigram PCXHR */ +- SNDRV_HWDEP_IFACE_SB_RC, /* SB Extigy/Audigy2NX remote control */ +- SNDRV_HWDEP_IFACE_HDA, /* HD-audio */ +- SNDRV_HWDEP_IFACE_USB_STREAM, /* direct access to usb stream */ +- SNDRV_HWDEP_IFACE_FW_DICE, /* TC DICE FireWire device */ +- SNDRV_HWDEP_IFACE_FW_FIREWORKS, /* Echo Audio Fireworks based device */ +- SNDRV_HWDEP_IFACE_FW_BEBOB, /* BridgeCo BeBoB based device */ +- SNDRV_HWDEP_IFACE_FW_OXFW, /* Oxford OXFW970/971 based device */ +- SNDRV_HWDEP_IFACE_FW_DIGI00X, /* Digidesign Digi 002/003 family */ +- SNDRV_HWDEP_IFACE_FW_TASCAM, /* TASCAM FireWire series */ +- SNDRV_HWDEP_IFACE_LINE6, /* Line6 USB processors */ +- SNDRV_HWDEP_IFACE_FW_MOTU, /* MOTU FireWire series */ +- SNDRV_HWDEP_IFACE_FW_FIREFACE, /* RME Fireface series */ +- +- /* Don't forget to change the following: */ +- SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_FIREFACE +-}; +- +-struct snd_hwdep_info { +- unsigned int device; /* WR: device number */ +- int card; /* R: card number */ +- unsigned char id[64]; /* ID (user selectable) */ +- unsigned char name[80]; /* hwdep name */ +- int iface; /* hwdep interface */ +- unsigned char reserved[64]; /* reserved for future */ +-}; +- +-/* generic DSP loader */ +-struct snd_hwdep_dsp_status { +- unsigned int version; /* R: driver-specific version */ +- unsigned char id[32]; /* R: driver-specific ID string */ +- unsigned int num_dsps; /* R: number of DSP images to transfer */ +- unsigned int dsp_loaded; /* R: bit flags indicating the loaded DSPs */ +- unsigned int chip_ready; /* R: 1 = initialization finished */ +- unsigned char reserved[16]; /* reserved for future use */ +-}; +- +-struct snd_hwdep_dsp_image { +- unsigned int index; /* W: DSP index */ +- unsigned char name[64]; /* W: ID (e.g. file name) */ +- unsigned char __user *image; /* W: binary image */ +- size_t length; /* W: size of image in bytes */ +- unsigned long driver_data; /* W: driver-specific data */ +-}; +- +-#define SNDRV_HWDEP_IOCTL_PVERSION _IOR ('H', 0x00, int) +-#define SNDRV_HWDEP_IOCTL_INFO _IOR ('H', 0x01, struct snd_hwdep_info) +-#define SNDRV_HWDEP_IOCTL_DSP_STATUS _IOR('H', 0x02, struct snd_hwdep_dsp_status) +-#define SNDRV_HWDEP_IOCTL_DSP_LOAD _IOW('H', 0x03, struct snd_hwdep_dsp_image) +- +-/***************************************************************************** +- * * +- * Digital Audio (PCM) interface - /dev/snd/pcm?? * +- * * +- *****************************************************************************/ +- +-#define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 14) +- +-typedef unsigned long snd_pcm_uframes_t; +-typedef signed long snd_pcm_sframes_t; +- +-enum { +- SNDRV_PCM_CLASS_GENERIC = 0, /* standard mono or stereo device */ +- SNDRV_PCM_CLASS_MULTI, /* multichannel device */ +- SNDRV_PCM_CLASS_MODEM, /* software modem class */ +- SNDRV_PCM_CLASS_DIGITIZER, /* digitizer class */ +- /* Don't forget to change the following: */ +- SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER, +-}; +- +-enum { +- SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */ +- SNDRV_PCM_SUBCLASS_MULTI_MIX, /* multichannel subdevices are mixed together */ +- /* Don't forget to change the following: */ +- SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX, +-}; +- +-enum { +- SNDRV_PCM_STREAM_PLAYBACK = 0, +- SNDRV_PCM_STREAM_CAPTURE, +- SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, +-}; +- +-typedef int __bitwise snd_pcm_access_t; +-#define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED ((__force snd_pcm_access_t) 0) /* interleaved mmap */ +-#define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED ((__force snd_pcm_access_t) 1) /* noninterleaved mmap */ +-#define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((__force snd_pcm_access_t) 2) /* complex mmap */ +-#define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((__force snd_pcm_access_t) 3) /* readi/writei */ +-#define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ((__force snd_pcm_access_t) 4) /* readn/writen */ +-#define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED +- +-typedef int __bitwise snd_pcm_format_t; +-#define SNDRV_PCM_FORMAT_S8 ((__force snd_pcm_format_t) 0) +-#define SNDRV_PCM_FORMAT_U8 ((__force snd_pcm_format_t) 1) +-#define SNDRV_PCM_FORMAT_S16_LE ((__force snd_pcm_format_t) 2) +-#define SNDRV_PCM_FORMAT_S16_BE ((__force snd_pcm_format_t) 3) +-#define SNDRV_PCM_FORMAT_U16_LE ((__force snd_pcm_format_t) 4) +-#define SNDRV_PCM_FORMAT_U16_BE ((__force snd_pcm_format_t) 5) +-#define SNDRV_PCM_FORMAT_S24_LE ((__force snd_pcm_format_t) 6) /* low three bytes */ +-#define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) /* low three bytes */ +-#define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) /* low three bytes */ +-#define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) /* low three bytes */ +-#define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10) +-#define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11) +-#define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12) +-#define SNDRV_PCM_FORMAT_U32_BE ((__force snd_pcm_format_t) 13) +-#define SNDRV_PCM_FORMAT_FLOAT_LE ((__force snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ +-#define SNDRV_PCM_FORMAT_FLOAT_BE ((__force snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ +-#define SNDRV_PCM_FORMAT_FLOAT64_LE ((__force snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ +-#define SNDRV_PCM_FORMAT_FLOAT64_BE ((__force snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ +-#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */ +-#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */ +-#define SNDRV_PCM_FORMAT_MU_LAW ((__force snd_pcm_format_t) 20) +-#define SNDRV_PCM_FORMAT_A_LAW ((__force snd_pcm_format_t) 21) +-#define SNDRV_PCM_FORMAT_IMA_ADPCM ((__force snd_pcm_format_t) 22) +-#define SNDRV_PCM_FORMAT_MPEG ((__force snd_pcm_format_t) 23) +-#define SNDRV_PCM_FORMAT_GSM ((__force snd_pcm_format_t) 24) +-#define SNDRV_PCM_FORMAT_S20_LE ((__force snd_pcm_format_t) 25) /* in four bytes, LSB justified */ +-#define SNDRV_PCM_FORMAT_S20_BE ((__force snd_pcm_format_t) 26) /* in four bytes, LSB justified */ +-#define SNDRV_PCM_FORMAT_U20_LE ((__force snd_pcm_format_t) 27) /* in four bytes, LSB justified */ +-#define SNDRV_PCM_FORMAT_U20_BE ((__force snd_pcm_format_t) 28) /* in four bytes, LSB justified */ +-/* gap in the numbering for a future standard linear format */ +-#define SNDRV_PCM_FORMAT_SPECIAL ((__force snd_pcm_format_t) 31) +-#define SNDRV_PCM_FORMAT_S24_3LE ((__force snd_pcm_format_t) 32) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_S24_3BE ((__force snd_pcm_format_t) 33) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_U24_3LE ((__force snd_pcm_format_t) 34) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_U24_3BE ((__force snd_pcm_format_t) 35) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_S20_3LE ((__force snd_pcm_format_t) 36) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_S20_3BE ((__force snd_pcm_format_t) 37) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_U20_3LE ((__force snd_pcm_format_t) 38) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_U20_3BE ((__force snd_pcm_format_t) 39) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_S18_3LE ((__force snd_pcm_format_t) 40) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_S18_3BE ((__force snd_pcm_format_t) 41) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_U18_3LE ((__force snd_pcm_format_t) 42) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_U18_3BE ((__force snd_pcm_format_t) 43) /* in three bytes */ +-#define SNDRV_PCM_FORMAT_G723_24 ((__force snd_pcm_format_t) 44) /* 8 samples in 3 bytes */ +-#define SNDRV_PCM_FORMAT_G723_24_1B ((__force snd_pcm_format_t) 45) /* 1 sample in 1 byte */ +-#define SNDRV_PCM_FORMAT_G723_40 ((__force snd_pcm_format_t) 46) /* 8 Samples in 5 bytes */ +-#define SNDRV_PCM_FORMAT_G723_40_1B ((__force snd_pcm_format_t) 47) /* 1 sample in 1 byte */ +-#define SNDRV_PCM_FORMAT_DSD_U8 ((__force snd_pcm_format_t) 48) /* DSD, 1-byte samples DSD (x8) */ +-#define SNDRV_PCM_FORMAT_DSD_U16_LE ((__force snd_pcm_format_t) 49) /* DSD, 2-byte samples DSD (x16), little endian */ +-#define SNDRV_PCM_FORMAT_DSD_U32_LE ((__force snd_pcm_format_t) 50) /* DSD, 4-byte samples DSD (x32), little endian */ +-#define SNDRV_PCM_FORMAT_DSD_U16_BE ((__force snd_pcm_format_t) 51) /* DSD, 2-byte samples DSD (x16), big endian */ +-#define SNDRV_PCM_FORMAT_DSD_U32_BE ((__force snd_pcm_format_t) 52) /* DSD, 4-byte samples DSD (x32), big endian */ +-#define SNDRV_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_DSD_U32_BE +-#define SNDRV_PCM_FORMAT_FIRST SNDRV_PCM_FORMAT_S8 +- +-#ifdef SNDRV_LITTLE_ENDIAN +-#define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_LE +-#define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_LE +-#define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_LE +-#define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_LE +-#define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_LE +-#define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_LE +-#define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_LE +-#define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_LE +-#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE +-#define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_LE +-#define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_LE +-#endif +-#ifdef SNDRV_BIG_ENDIAN +-#define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_BE +-#define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_BE +-#define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_BE +-#define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_BE +-#define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_BE +-#define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_BE +-#define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_BE +-#define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_BE +-#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE +-#define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_BE +-#define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_BE +-#endif +- +-typedef int __bitwise snd_pcm_subformat_t; +-#define SNDRV_PCM_SUBFORMAT_STD ((__force snd_pcm_subformat_t) 0) +-#define SNDRV_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_STD +- +-#define SNDRV_PCM_INFO_MMAP 0x00000001 /* hardware supports mmap */ +-#define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 /* period data are valid during transfer */ +-#define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ +-#define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ +-#define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ +-#define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ +-#define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ +-#define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +-#define SNDRV_PCM_INFO_BLOCK_TRANSFER 0x00010000 /* hardware transfer block of samples */ +-#define SNDRV_PCM_INFO_OVERRANGE 0x00020000 /* hardware supports ADC (capture) overrange detection */ +-#define SNDRV_PCM_INFO_RESUME 0x00040000 /* hardware supports stream resume after suspend */ +-#define SNDRV_PCM_INFO_PAUSE 0x00080000 /* pause ioctl is supported */ +-#define SNDRV_PCM_INFO_HALF_DUPLEX 0x00100000 /* only half duplex */ +-#define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 /* playback and capture stream are somewhat correlated */ +-#define SNDRV_PCM_INFO_SYNC_START 0x00400000 /* pcm support some kind of sync go */ +-#define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP 0x00800000 /* period wakeup can be disabled */ +-#define SNDRV_PCM_INFO_HAS_WALL_CLOCK 0x01000000 /* (Deprecated)has audio wall clock for audio/system time sync */ +-#define SNDRV_PCM_INFO_HAS_LINK_ATIME 0x01000000 /* report hardware link audio time, reset on startup */ +-#define SNDRV_PCM_INFO_HAS_LINK_ABSOLUTE_ATIME 0x02000000 /* report absolute hardware link audio time, not reset on startup */ +-#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME 0x04000000 /* report estimated link audio time */ +-#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000 /* report synchronized audio/system time */ +- +-#define SNDRV_PCM_INFO_DRAIN_TRIGGER 0x40000000 /* internal kernel flag - trigger in drain */ +-#define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 /* internal kernel flag - FIFO size is in frames */ +- +- +- +-typedef int __bitwise snd_pcm_state_t; +-#define SNDRV_PCM_STATE_OPEN ((__force snd_pcm_state_t) 0) /* stream is open */ +-#define SNDRV_PCM_STATE_SETUP ((__force snd_pcm_state_t) 1) /* stream has a setup */ +-#define SNDRV_PCM_STATE_PREPARED ((__force snd_pcm_state_t) 2) /* stream is ready to start */ +-#define SNDRV_PCM_STATE_RUNNING ((__force snd_pcm_state_t) 3) /* stream is running */ +-#define SNDRV_PCM_STATE_XRUN ((__force snd_pcm_state_t) 4) /* stream reached an xrun */ +-#define SNDRV_PCM_STATE_DRAINING ((__force snd_pcm_state_t) 5) /* stream is draining */ +-#define SNDRV_PCM_STATE_PAUSED ((__force snd_pcm_state_t) 6) /* stream is paused */ +-#define SNDRV_PCM_STATE_SUSPENDED ((__force snd_pcm_state_t) 7) /* hardware is suspended */ +-#define SNDRV_PCM_STATE_DISCONNECTED ((__force snd_pcm_state_t) 8) /* hardware is disconnected */ +-#define SNDRV_PCM_STATE_LAST SNDRV_PCM_STATE_DISCONNECTED +- +-enum { +- SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000, +- SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000, +- SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000, +-}; +- +-union snd_pcm_sync_id { +- unsigned char id[16]; +- unsigned short id16[8]; +- unsigned int id32[4]; +-}; +- +-struct snd_pcm_info { +- unsigned int device; /* RO/WR (control): device number */ +- unsigned int subdevice; /* RO/WR (control): subdevice number */ +- int stream; /* RO/WR (control): stream direction */ +- int card; /* R: card number */ +- unsigned char id[64]; /* ID (user selectable) */ +- unsigned char name[80]; /* name of this device */ +- unsigned char subname[32]; /* subdevice name */ +- int dev_class; /* SNDRV_PCM_CLASS_* */ +- int dev_subclass; /* SNDRV_PCM_SUBCLASS_* */ +- unsigned int subdevices_count; +- unsigned int subdevices_avail; +- union snd_pcm_sync_id sync; /* hardware synchronization ID */ +- unsigned char reserved[64]; /* reserved for future... */ +-}; +- +-typedef int snd_pcm_hw_param_t; +-#define SNDRV_PCM_HW_PARAM_ACCESS 0 /* Access type */ +-#define SNDRV_PCM_HW_PARAM_FORMAT 1 /* Format */ +-#define SNDRV_PCM_HW_PARAM_SUBFORMAT 2 /* Subformat */ +-#define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS +-#define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT +- +-#define SNDRV_PCM_HW_PARAM_SAMPLE_BITS 8 /* Bits per sample */ +-#define SNDRV_PCM_HW_PARAM_FRAME_BITS 9 /* Bits per frame */ +-#define SNDRV_PCM_HW_PARAM_CHANNELS 10 /* Channels */ +-#define SNDRV_PCM_HW_PARAM_RATE 11 /* Approx rate */ +-#define SNDRV_PCM_HW_PARAM_PERIOD_TIME 12 /* Approx distance between +- * interrupts in us +- */ +-#define SNDRV_PCM_HW_PARAM_PERIOD_SIZE 13 /* Approx frames between +- * interrupts +- */ +-#define SNDRV_PCM_HW_PARAM_PERIOD_BYTES 14 /* Approx bytes between +- * interrupts +- */ +-#define SNDRV_PCM_HW_PARAM_PERIODS 15 /* Approx interrupts per +- * buffer +- */ +-#define SNDRV_PCM_HW_PARAM_BUFFER_TIME 16 /* Approx duration of buffer +- * in us +- */ +-#define SNDRV_PCM_HW_PARAM_BUFFER_SIZE 17 /* Size of buffer in frames */ +-#define SNDRV_PCM_HW_PARAM_BUFFER_BYTES 18 /* Size of buffer in bytes */ +-#define SNDRV_PCM_HW_PARAM_TICK_TIME 19 /* Approx tick duration in us */ +-#define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_SAMPLE_BITS +-#define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME +- +-#define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ +-#define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ +-#define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ +- +-struct snd_interval { +- unsigned int min, max; +- unsigned int openmin:1, +- openmax:1, +- integer:1, +- empty:1; +-}; +- +-#define SNDRV_MASK_MAX 256 +- +-struct snd_mask { +- __u32 bits[(SNDRV_MASK_MAX+31)/32]; +-}; +- +-struct snd_pcm_hw_params { +- unsigned int flags; +- struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - +- SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; +- struct snd_mask mres[5]; /* reserved masks */ +- struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - +- SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; +- struct snd_interval ires[9]; /* reserved intervals */ +- unsigned int rmask; /* W: requested masks */ +- unsigned int cmask; /* R: changed masks */ +- unsigned int info; /* R: Info flags for returned setup */ +- unsigned int msbits; /* R: used most significant bits */ +- unsigned int rate_num; /* R: rate numerator */ +- unsigned int rate_den; /* R: rate denominator */ +- snd_pcm_uframes_t fifo_size; /* R: chip FIFO size in frames */ +- unsigned char reserved[64]; /* reserved for future */ +-}; +- +-enum { +- SNDRV_PCM_TSTAMP_NONE = 0, +- SNDRV_PCM_TSTAMP_ENABLE, +- SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE, +-}; +- +-struct snd_pcm_sw_params { +- int tstamp_mode; /* timestamp mode */ +- unsigned int period_step; +- unsigned int sleep_min; /* min ticks to sleep */ +- snd_pcm_uframes_t avail_min; /* min avail frames for wakeup */ +- snd_pcm_uframes_t xfer_align; /* obsolete: xfer size need to be a multiple */ +- snd_pcm_uframes_t start_threshold; /* min hw_avail frames for automatic start */ +- snd_pcm_uframes_t stop_threshold; /* min avail frames for automatic stop */ +- snd_pcm_uframes_t silence_threshold; /* min distance from noise for silence filling */ +- snd_pcm_uframes_t silence_size; /* silence block size */ +- snd_pcm_uframes_t boundary; /* pointers wrap point */ +- unsigned int proto; /* protocol version */ +- unsigned int tstamp_type; /* timestamp type (req. proto >= 2.0.12) */ +- unsigned char reserved[56]; /* reserved for future */ +-}; +- +-struct snd_pcm_channel_info { +- unsigned int channel; +- __kernel_off_t offset; /* mmap offset */ +- unsigned int first; /* offset to first sample in bits */ +- unsigned int step; /* samples distance in bits */ +-}; +- +-enum { +- /* +- * first definition for backwards compatibility only, +- * maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else +- */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0, +- +- /* timestamp definitions */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1, /* DMA time, reported as per hw_ptr */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2, /* link time reported by sample or wallclock counter, reset on startup */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3, /* link time reported by sample or wallclock counter, not reset on startup */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4, /* link time estimated indirectly */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, /* link time synchronized with system time */ +- SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED +-}; +- +-struct snd_pcm_status { +- snd_pcm_state_t state; /* stream state */ +- struct timespec trigger_tstamp; /* time when stream was started/stopped/paused */ +- struct timespec tstamp; /* reference timestamp */ +- snd_pcm_uframes_t appl_ptr; /* appl ptr */ +- snd_pcm_uframes_t hw_ptr; /* hw ptr */ +- snd_pcm_sframes_t delay; /* current delay in frames */ +- snd_pcm_uframes_t avail; /* number of frames available */ +- snd_pcm_uframes_t avail_max; /* max frames available on hw since last status */ +- snd_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */ +- snd_pcm_state_t suspended_state; /* suspended stream state */ +- __u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */ +- struct timespec audio_tstamp; /* sample counter, wall clock, PHC or on-demand sync'ed */ +- struct timespec driver_tstamp; /* useful in case reference system tstamp is reported with delay */ +- __u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */ +- unsigned char reserved[52-2*sizeof(struct timespec)]; /* must be filled with zero */ +-}; +- +-struct snd_pcm_mmap_status { +- snd_pcm_state_t state; /* RO: state - SNDRV_PCM_STATE_XXXX */ +- int pad1; /* Needed for 64 bit alignment */ +- snd_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */ +- struct timespec tstamp; /* Timestamp */ +- snd_pcm_state_t suspended_state; /* RO: suspended stream state */ +- struct timespec audio_tstamp; /* from sample counter or wall clock */ +-}; +- +-struct snd_pcm_mmap_control { +- snd_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */ +- snd_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */ +-}; +- +-#define SNDRV_PCM_SYNC_PTR_HWSYNC (1<<0) /* execute hwsync */ +-#define SNDRV_PCM_SYNC_PTR_APPL (1<<1) /* get appl_ptr from driver (r/w op) */ +-#define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1<<2) /* get avail_min from driver */ +- +-struct snd_pcm_sync_ptr { +- unsigned int flags; +- union { +- struct snd_pcm_mmap_status status; +- unsigned char reserved[64]; +- } s; +- union { +- struct snd_pcm_mmap_control control; +- unsigned char reserved[64]; +- } c; +-}; +- +-struct snd_xferi { +- snd_pcm_sframes_t result; +- void __user *buf; +- snd_pcm_uframes_t frames; +-}; +- +-struct snd_xfern { +- snd_pcm_sframes_t result; +- void __user * __user *bufs; +- snd_pcm_uframes_t frames; +-}; +- +-enum { +- SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, /* gettimeofday equivalent */ +- SNDRV_PCM_TSTAMP_TYPE_MONOTONIC, /* posix_clock_monotonic equivalent */ +- SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, /* monotonic_raw (no NTP) */ +- SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, +-}; +- +-/* channel positions */ +-enum { +- SNDRV_CHMAP_UNKNOWN = 0, +- SNDRV_CHMAP_NA, /* N/A, silent */ +- SNDRV_CHMAP_MONO, /* mono stream */ +- /* this follows the alsa-lib mixer channel value + 3 */ +- SNDRV_CHMAP_FL, /* front left */ +- SNDRV_CHMAP_FR, /* front right */ +- SNDRV_CHMAP_RL, /* rear left */ +- SNDRV_CHMAP_RR, /* rear right */ +- SNDRV_CHMAP_FC, /* front center */ +- SNDRV_CHMAP_LFE, /* LFE */ +- SNDRV_CHMAP_SL, /* side left */ +- SNDRV_CHMAP_SR, /* side right */ +- SNDRV_CHMAP_RC, /* rear center */ +- /* new definitions */ +- SNDRV_CHMAP_FLC, /* front left center */ +- SNDRV_CHMAP_FRC, /* front right center */ +- SNDRV_CHMAP_RLC, /* rear left center */ +- SNDRV_CHMAP_RRC, /* rear right center */ +- SNDRV_CHMAP_FLW, /* front left wide */ +- SNDRV_CHMAP_FRW, /* front right wide */ +- SNDRV_CHMAP_FLH, /* front left high */ +- SNDRV_CHMAP_FCH, /* front center high */ +- SNDRV_CHMAP_FRH, /* front right high */ +- SNDRV_CHMAP_TC, /* top center */ +- SNDRV_CHMAP_TFL, /* top front left */ +- SNDRV_CHMAP_TFR, /* top front right */ +- SNDRV_CHMAP_TFC, /* top front center */ +- SNDRV_CHMAP_TRL, /* top rear left */ +- SNDRV_CHMAP_TRR, /* top rear right */ +- SNDRV_CHMAP_TRC, /* top rear center */ +- /* new definitions for UAC2 */ +- SNDRV_CHMAP_TFLC, /* top front left center */ +- SNDRV_CHMAP_TFRC, /* top front right center */ +- SNDRV_CHMAP_TSL, /* top side left */ +- SNDRV_CHMAP_TSR, /* top side right */ +- SNDRV_CHMAP_LLFE, /* left LFE */ +- SNDRV_CHMAP_RLFE, /* right LFE */ +- SNDRV_CHMAP_BC, /* bottom center */ +- SNDRV_CHMAP_BLC, /* bottom left center */ +- SNDRV_CHMAP_BRC, /* bottom right center */ +- SNDRV_CHMAP_LAST = SNDRV_CHMAP_BRC, +-}; +- +-#define SNDRV_CHMAP_POSITION_MASK 0xffff +-#define SNDRV_CHMAP_PHASE_INVERSE (0x01 << 16) +-#define SNDRV_CHMAP_DRIVER_SPEC (0x02 << 16) +- +-#define SNDRV_PCM_IOCTL_PVERSION _IOR('A', 0x00, int) +-#define SNDRV_PCM_IOCTL_INFO _IOR('A', 0x01, struct snd_pcm_info) +-#define SNDRV_PCM_IOCTL_TSTAMP _IOW('A', 0x02, int) +-#define SNDRV_PCM_IOCTL_TTSTAMP _IOW('A', 0x03, int) +-#define SNDRV_PCM_IOCTL_USER_PVERSION _IOW('A', 0x04, int) +-#define SNDRV_PCM_IOCTL_HW_REFINE _IOWR('A', 0x10, struct snd_pcm_hw_params) +-#define SNDRV_PCM_IOCTL_HW_PARAMS _IOWR('A', 0x11, struct snd_pcm_hw_params) +-#define SNDRV_PCM_IOCTL_HW_FREE _IO('A', 0x12) +-#define SNDRV_PCM_IOCTL_SW_PARAMS _IOWR('A', 0x13, struct snd_pcm_sw_params) +-#define SNDRV_PCM_IOCTL_STATUS _IOR('A', 0x20, struct snd_pcm_status) +-#define SNDRV_PCM_IOCTL_DELAY _IOR('A', 0x21, snd_pcm_sframes_t) +-#define SNDRV_PCM_IOCTL_HWSYNC _IO('A', 0x22) +-#define SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct snd_pcm_sync_ptr) +-#define SNDRV_PCM_IOCTL_STATUS_EXT _IOWR('A', 0x24, struct snd_pcm_status) +-#define SNDRV_PCM_IOCTL_CHANNEL_INFO _IOR('A', 0x32, struct snd_pcm_channel_info) +-#define SNDRV_PCM_IOCTL_PREPARE _IO('A', 0x40) +-#define SNDRV_PCM_IOCTL_RESET _IO('A', 0x41) +-#define SNDRV_PCM_IOCTL_START _IO('A', 0x42) +-#define SNDRV_PCM_IOCTL_DROP _IO('A', 0x43) +-#define SNDRV_PCM_IOCTL_DRAIN _IO('A', 0x44) +-#define SNDRV_PCM_IOCTL_PAUSE _IOW('A', 0x45, int) +-#define SNDRV_PCM_IOCTL_REWIND _IOW('A', 0x46, snd_pcm_uframes_t) +-#define SNDRV_PCM_IOCTL_RESUME _IO('A', 0x47) +-#define SNDRV_PCM_IOCTL_XRUN _IO('A', 0x48) +-#define SNDRV_PCM_IOCTL_FORWARD _IOW('A', 0x49, snd_pcm_uframes_t) +-#define SNDRV_PCM_IOCTL_WRITEI_FRAMES _IOW('A', 0x50, struct snd_xferi) +-#define SNDRV_PCM_IOCTL_READI_FRAMES _IOR('A', 0x51, struct snd_xferi) +-#define SNDRV_PCM_IOCTL_WRITEN_FRAMES _IOW('A', 0x52, struct snd_xfern) +-#define SNDRV_PCM_IOCTL_READN_FRAMES _IOR('A', 0x53, struct snd_xfern) +-#define SNDRV_PCM_IOCTL_LINK _IOW('A', 0x60, int) +-#define SNDRV_PCM_IOCTL_UNLINK _IO('A', 0x61) +- +-/***************************************************************************** +- * * +- * MIDI v1.0 interface * +- * * +- *****************************************************************************/ +- +-/* +- * Raw MIDI section - /dev/snd/midi?? +- */ +- +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 0) +- +-enum { +- SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +- SNDRV_RAWMIDI_STREAM_INPUT, +- SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT, +-}; +- +-#define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 +-#define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 +-#define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 +- +-struct snd_rawmidi_info { +- unsigned int device; /* RO/WR (control): device number */ +- unsigned int subdevice; /* RO/WR (control): subdevice number */ +- int stream; /* WR: stream */ +- int card; /* R: card number */ +- unsigned int flags; /* SNDRV_RAWMIDI_INFO_XXXX */ +- unsigned char id[64]; /* ID (user selectable) */ +- unsigned char name[80]; /* name of device */ +- unsigned char subname[32]; /* name of active or selected subdevice */ +- unsigned int subdevices_count; +- unsigned int subdevices_avail; +- unsigned char reserved[64]; /* reserved for future use */ +-}; +- +-struct snd_rawmidi_params { +- int stream; +- size_t buffer_size; /* queue size in bytes */ +- size_t avail_min; /* minimum avail bytes for wakeup */ +- unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */ +- unsigned char reserved[16]; /* reserved for future use */ +-}; +- +-struct snd_rawmidi_status { +- int stream; +- struct timespec tstamp; /* Timestamp */ +- size_t avail; /* available bytes */ +- size_t xruns; /* count of overruns since last status (in bytes) */ +- unsigned char reserved[16]; /* reserved for future use */ +-}; +- +-#define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) +-#define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) +-#define SNDRV_RAWMIDI_IOCTL_PARAMS _IOWR('W', 0x10, struct snd_rawmidi_params) +-#define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) +-#define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) +-#define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) +- +-/* +- * Timer section - /dev/snd/timer +- */ +- +-#define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 6) +- +-enum { +- SNDRV_TIMER_CLASS_NONE = -1, +- SNDRV_TIMER_CLASS_SLAVE = 0, +- SNDRV_TIMER_CLASS_GLOBAL, +- SNDRV_TIMER_CLASS_CARD, +- SNDRV_TIMER_CLASS_PCM, +- SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM, +-}; +- +-/* slave timer classes */ +-enum { +- SNDRV_TIMER_SCLASS_NONE = 0, +- SNDRV_TIMER_SCLASS_APPLICATION, +- SNDRV_TIMER_SCLASS_SEQUENCER, /* alias */ +- SNDRV_TIMER_SCLASS_OSS_SEQUENCER, /* alias */ +- SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER, +-}; +- +-/* global timers (device member) */ +-#define SNDRV_TIMER_GLOBAL_SYSTEM 0 +-#define SNDRV_TIMER_GLOBAL_RTC 1 /* unused */ +-#define SNDRV_TIMER_GLOBAL_HPET 2 +-#define SNDRV_TIMER_GLOBAL_HRTIMER 3 +- +-/* info flags */ +-#define SNDRV_TIMER_FLG_SLAVE (1<<0) /* cannot be controlled */ +- +-struct snd_timer_id { +- int dev_class; +- int dev_sclass; +- int card; +- int device; +- int subdevice; +-}; +- +-struct snd_timer_ginfo { +- struct snd_timer_id tid; /* requested timer ID */ +- unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ +- int card; /* card number */ +- unsigned char id[64]; /* timer identification */ +- unsigned char name[80]; /* timer name */ +- unsigned long reserved0; /* reserved for future use */ +- unsigned long resolution; /* average period resolution in ns */ +- unsigned long resolution_min; /* minimal period resolution in ns */ +- unsigned long resolution_max; /* maximal period resolution in ns */ +- unsigned int clients; /* active timer clients */ +- unsigned char reserved[32]; +-}; +- +-struct snd_timer_gparams { +- struct snd_timer_id tid; /* requested timer ID */ +- unsigned long period_num; /* requested precise period duration (in seconds) - numerator */ +- unsigned long period_den; /* requested precise period duration (in seconds) - denominator */ +- unsigned char reserved[32]; +-}; +- +-struct snd_timer_gstatus { +- struct snd_timer_id tid; /* requested timer ID */ +- unsigned long resolution; /* current period resolution in ns */ +- unsigned long resolution_num; /* precise current period resolution (in seconds) - numerator */ +- unsigned long resolution_den; /* precise current period resolution (in seconds) - denominator */ +- unsigned char reserved[32]; +-}; +- +-struct snd_timer_select { +- struct snd_timer_id id; /* bind to timer ID */ +- unsigned char reserved[32]; /* reserved */ +-}; +- +-struct snd_timer_info { +- unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ +- int card; /* card number */ +- unsigned char id[64]; /* timer identificator */ +- unsigned char name[80]; /* timer name */ +- unsigned long reserved0; /* reserved for future use */ +- unsigned long resolution; /* average period resolution in ns */ +- unsigned char reserved[64]; /* reserved */ +-}; +- +-#define SNDRV_TIMER_PSFLG_AUTO (1<<0) /* auto start, otherwise one-shot */ +-#define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) /* exclusive use, precise start/stop/pause/continue */ +-#define SNDRV_TIMER_PSFLG_EARLY_EVENT (1<<2) /* write early event to the poll queue */ +- +-struct snd_timer_params { +- unsigned int flags; /* flags - SNDRV_TIMER_PSFLG_* */ +- unsigned int ticks; /* requested resolution in ticks */ +- unsigned int queue_size; /* total size of queue (32-1024) */ +- unsigned int reserved0; /* reserved, was: failure locations */ +- unsigned int filter; /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */ +- unsigned char reserved[60]; /* reserved */ +-}; +- +-struct snd_timer_status { +- struct timespec tstamp; /* Timestamp - last update */ +- unsigned int resolution; /* current period resolution in ns */ +- unsigned int lost; /* counter of master tick lost */ +- unsigned int overrun; /* count of read queue overruns */ +- unsigned int queue; /* used queue size */ +- unsigned char reserved[64]; /* reserved */ +-}; +- +-#define SNDRV_TIMER_IOCTL_PVERSION _IOR('T', 0x00, int) +-#define SNDRV_TIMER_IOCTL_NEXT_DEVICE _IOWR('T', 0x01, struct snd_timer_id) +-#define SNDRV_TIMER_IOCTL_TREAD _IOW('T', 0x02, int) +-#define SNDRV_TIMER_IOCTL_GINFO _IOWR('T', 0x03, struct snd_timer_ginfo) +-#define SNDRV_TIMER_IOCTL_GPARAMS _IOW('T', 0x04, struct snd_timer_gparams) +-#define SNDRV_TIMER_IOCTL_GSTATUS _IOWR('T', 0x05, struct snd_timer_gstatus) +-#define SNDRV_TIMER_IOCTL_SELECT _IOW('T', 0x10, struct snd_timer_select) +-#define SNDRV_TIMER_IOCTL_INFO _IOR('T', 0x11, struct snd_timer_info) +-#define SNDRV_TIMER_IOCTL_PARAMS _IOW('T', 0x12, struct snd_timer_params) +-#define SNDRV_TIMER_IOCTL_STATUS _IOR('T', 0x14, struct snd_timer_status) +-/* The following four ioctls are changed since 1.0.9 due to confliction */ +-#define SNDRV_TIMER_IOCTL_START _IO('T', 0xa0) +-#define SNDRV_TIMER_IOCTL_STOP _IO('T', 0xa1) +-#define SNDRV_TIMER_IOCTL_CONTINUE _IO('T', 0xa2) +-#define SNDRV_TIMER_IOCTL_PAUSE _IO('T', 0xa3) +- +-struct snd_timer_read { +- unsigned int resolution; +- unsigned int ticks; +-}; +- +-enum { +- SNDRV_TIMER_EVENT_RESOLUTION = 0, /* val = resolution in ns */ +- SNDRV_TIMER_EVENT_TICK, /* val = ticks */ +- SNDRV_TIMER_EVENT_START, /* val = resolution in ns */ +- SNDRV_TIMER_EVENT_STOP, /* val = 0 */ +- SNDRV_TIMER_EVENT_CONTINUE, /* val = resolution in ns */ +- SNDRV_TIMER_EVENT_PAUSE, /* val = 0 */ +- SNDRV_TIMER_EVENT_EARLY, /* val = 0, early event */ +- SNDRV_TIMER_EVENT_SUSPEND, /* val = 0 */ +- SNDRV_TIMER_EVENT_RESUME, /* val = resolution in ns */ +- /* master timer events for slave timer instances */ +- SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10, +- SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10, +- SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10, +- SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10, +- SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10, +- SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10, +-}; +- +-struct snd_timer_tread { +- int event; +- struct timespec tstamp; +- unsigned int val; +-}; +- +-/**************************************************************************** +- * * +- * Section for driver control interface - /dev/snd/control? * +- * * +- ****************************************************************************/ +- +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 7) +- +-struct snd_ctl_card_info { +- int card; /* card number */ +- int pad; /* reserved for future (was type) */ +- unsigned char id[16]; /* ID of card (user selectable) */ +- unsigned char driver[16]; /* Driver name */ +- unsigned char name[32]; /* Short name of soundcard */ +- unsigned char longname[80]; /* name + info text about soundcard */ +- unsigned char reserved_[16]; /* reserved for future (was ID of mixer) */ +- unsigned char mixername[80]; /* visual mixer identification */ +- unsigned char components[128]; /* card components / fine identification, delimited with one space (AC97 etc..) */ +-}; +- +-typedef int __bitwise snd_ctl_elem_type_t; +-#define SNDRV_CTL_ELEM_TYPE_NONE ((__force snd_ctl_elem_type_t) 0) /* invalid */ +-#define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((__force snd_ctl_elem_type_t) 1) /* boolean type */ +-#define SNDRV_CTL_ELEM_TYPE_INTEGER ((__force snd_ctl_elem_type_t) 2) /* integer type */ +-#define SNDRV_CTL_ELEM_TYPE_ENUMERATED ((__force snd_ctl_elem_type_t) 3) /* enumerated type */ +-#define SNDRV_CTL_ELEM_TYPE_BYTES ((__force snd_ctl_elem_type_t) 4) /* byte array */ +-#define SNDRV_CTL_ELEM_TYPE_IEC958 ((__force snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */ +-#define SNDRV_CTL_ELEM_TYPE_INTEGER64 ((__force snd_ctl_elem_type_t) 6) /* 64-bit integer type */ +-#define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 +- +-typedef int __bitwise snd_ctl_elem_iface_t; +-#define SNDRV_CTL_ELEM_IFACE_CARD ((__force snd_ctl_elem_iface_t) 0) /* global control */ +-#define SNDRV_CTL_ELEM_IFACE_HWDEP ((__force snd_ctl_elem_iface_t) 1) /* hardware dependent device */ +-#define SNDRV_CTL_ELEM_IFACE_MIXER ((__force snd_ctl_elem_iface_t) 2) /* virtual mixer device */ +-#define SNDRV_CTL_ELEM_IFACE_PCM ((__force snd_ctl_elem_iface_t) 3) /* PCM device */ +-#define SNDRV_CTL_ELEM_IFACE_RAWMIDI ((__force snd_ctl_elem_iface_t) 4) /* RawMidi device */ +-#define SNDRV_CTL_ELEM_IFACE_TIMER ((__force snd_ctl_elem_iface_t) 5) /* timer device */ +-#define SNDRV_CTL_ELEM_IFACE_SEQUENCER ((__force snd_ctl_elem_iface_t) 6) /* sequencer client */ +-#define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER +- +-#define SNDRV_CTL_ELEM_ACCESS_READ (1<<0) +-#define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1) +-#define SNDRV_CTL_ELEM_ACCESS_READWRITE (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE) +-#define SNDRV_CTL_ELEM_ACCESS_VOLATILE (1<<2) /* control value may be changed without a notification */ +-#define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP (1<<3) /* when was control changed */ +-#define SNDRV_CTL_ELEM_ACCESS_TLV_READ (1<<4) /* TLV read is possible */ +-#define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE (1<<5) /* TLV write is possible */ +-#define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE (SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) +-#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND (1<<6) /* TLV command is possible */ +-#define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) /* control does actually nothing, but may be updated */ +-#define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) /* write lock */ +-#define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) /* write lock owner */ +-#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) /* kernel use a TLV callback */ +-#define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) /* user space element */ +-/* bits 30 and 31 are obsoleted (for indirect access) */ +- +-/* for further details see the ACPI and PCI power management specification */ +-#define SNDRV_CTL_POWER_D0 0x0000 /* full On */ +-#define SNDRV_CTL_POWER_D1 0x0100 /* partial On */ +-#define SNDRV_CTL_POWER_D2 0x0200 /* partial On */ +-#define SNDRV_CTL_POWER_D3 0x0300 /* Off */ +-#define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3|0x0000) /* Off, with power */ +-#define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3|0x0001) /* Off, without power */ +- +-#define SNDRV_CTL_ELEM_ID_NAME_MAXLEN 44 +- +-struct snd_ctl_elem_id { +- unsigned int numid; /* numeric identifier, zero = invalid */ +- snd_ctl_elem_iface_t iface; /* interface identifier */ +- unsigned int device; /* device/client number */ +- unsigned int subdevice; /* subdevice (substream) number */ +- unsigned char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* ASCII name of item */ +- unsigned int index; /* index of item */ +-}; +- +-struct snd_ctl_elem_list { +- unsigned int offset; /* W: first element ID to get */ +- unsigned int space; /* W: count of element IDs to get */ +- unsigned int used; /* R: count of element IDs set */ +- unsigned int count; /* R: count of all elements */ +- struct snd_ctl_elem_id __user *pids; /* R: IDs */ +- unsigned char reserved[50]; +-}; +- +-struct snd_ctl_elem_info { +- struct snd_ctl_elem_id id; /* W: element ID */ +- snd_ctl_elem_type_t type; /* R: value type - SNDRV_CTL_ELEM_TYPE_* */ +- unsigned int access; /* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */ +- unsigned int count; /* count of values */ +- __kernel_pid_t owner; /* owner's PID of this control */ +- union { +- struct { +- long min; /* R: minimum value */ +- long max; /* R: maximum value */ +- long step; /* R: step (0 variable) */ +- } integer; +- struct { +- long long min; /* R: minimum value */ +- long long max; /* R: maximum value */ +- long long step; /* R: step (0 variable) */ +- } integer64; +- struct { +- unsigned int items; /* R: number of items */ +- unsigned int item; /* W: item number */ +- char name[64]; /* R: value name */ +- __u64 names_ptr; /* W: names list (ELEM_ADD only) */ +- unsigned int names_length; +- } enumerated; +- unsigned char reserved[128]; +- } value; +- union { +- unsigned short d[4]; /* dimensions */ +- unsigned short *d_ptr; /* indirect - obsoleted */ +- } dimen; +- unsigned char reserved[64-4*sizeof(unsigned short)]; +-}; +- +-struct snd_ctl_elem_value { +- struct snd_ctl_elem_id id; /* W: element ID */ +- unsigned int indirect: 1; /* W: indirect access - obsoleted */ +- union { +- union { +- long value[128]; +- long *value_ptr; /* obsoleted */ +- } integer; +- union { +- long long value[64]; +- long long *value_ptr; /* obsoleted */ +- } integer64; +- union { +- unsigned int item[128]; +- unsigned int *item_ptr; /* obsoleted */ +- } enumerated; +- union { +- unsigned char data[512]; +- unsigned char *data_ptr; /* obsoleted */ +- } bytes; +- struct snd_aes_iec958 iec958; +- } value; /* RO */ +- struct timespec tstamp; +- unsigned char reserved[128-sizeof(struct timespec)]; +-}; +- +-struct snd_ctl_tlv { +- unsigned int numid; /* control element numeric identification */ +- unsigned int length; /* in bytes aligned to 4 */ +- unsigned int tlv[0]; /* first TLV */ +-}; +- +-#define SNDRV_CTL_IOCTL_PVERSION _IOR('U', 0x00, int) +-#define SNDRV_CTL_IOCTL_CARD_INFO _IOR('U', 0x01, struct snd_ctl_card_info) +-#define SNDRV_CTL_IOCTL_ELEM_LIST _IOWR('U', 0x10, struct snd_ctl_elem_list) +-#define SNDRV_CTL_IOCTL_ELEM_INFO _IOWR('U', 0x11, struct snd_ctl_elem_info) +-#define SNDRV_CTL_IOCTL_ELEM_READ _IOWR('U', 0x12, struct snd_ctl_elem_value) +-#define SNDRV_CTL_IOCTL_ELEM_WRITE _IOWR('U', 0x13, struct snd_ctl_elem_value) +-#define SNDRV_CTL_IOCTL_ELEM_LOCK _IOW('U', 0x14, struct snd_ctl_elem_id) +-#define SNDRV_CTL_IOCTL_ELEM_UNLOCK _IOW('U', 0x15, struct snd_ctl_elem_id) +-#define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int) +-#define SNDRV_CTL_IOCTL_ELEM_ADD _IOWR('U', 0x17, struct snd_ctl_elem_info) +-#define SNDRV_CTL_IOCTL_ELEM_REPLACE _IOWR('U', 0x18, struct snd_ctl_elem_info) +-#define SNDRV_CTL_IOCTL_ELEM_REMOVE _IOWR('U', 0x19, struct snd_ctl_elem_id) +-#define SNDRV_CTL_IOCTL_TLV_READ _IOWR('U', 0x1a, struct snd_ctl_tlv) +-#define SNDRV_CTL_IOCTL_TLV_WRITE _IOWR('U', 0x1b, struct snd_ctl_tlv) +-#define SNDRV_CTL_IOCTL_TLV_COMMAND _IOWR('U', 0x1c, struct snd_ctl_tlv) +-#define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int) +-#define SNDRV_CTL_IOCTL_HWDEP_INFO _IOR('U', 0x21, struct snd_hwdep_info) +-#define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int) +-#define SNDRV_CTL_IOCTL_PCM_INFO _IOWR('U', 0x31, struct snd_pcm_info) +-#define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int) +-#define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) +-#define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) +-#define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) +-#define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) +-#define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) +- +-/* +- * Read interface. +- */ +- +-enum sndrv_ctl_event_type { +- SNDRV_CTL_EVENT_ELEM = 0, +- SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM, +-}; +- +-#define SNDRV_CTL_EVENT_MASK_VALUE (1<<0) /* element value was changed */ +-#define SNDRV_CTL_EVENT_MASK_INFO (1<<1) /* element info was changed */ +-#define SNDRV_CTL_EVENT_MASK_ADD (1<<2) /* element was added */ +-#define SNDRV_CTL_EVENT_MASK_TLV (1<<3) /* element TLV tree was changed */ +-#define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) /* element was removed */ +- +-struct snd_ctl_event { +- int type; /* event type - SNDRV_CTL_EVENT_* */ +- union { +- struct { +- unsigned int mask; +- struct snd_ctl_elem_id id; +- } elem; +- unsigned char data8[60]; +- } data; +-}; +- +-/* +- * Control names +- */ +- +-#define SNDRV_CTL_NAME_NONE "" +-#define SNDRV_CTL_NAME_PLAYBACK "Playback " +-#define SNDRV_CTL_NAME_CAPTURE "Capture " +- +-#define SNDRV_CTL_NAME_IEC958_NONE "" +-#define SNDRV_CTL_NAME_IEC958_SWITCH "Switch" +-#define SNDRV_CTL_NAME_IEC958_VOLUME "Volume" +-#define SNDRV_CTL_NAME_IEC958_DEFAULT "Default" +-#define SNDRV_CTL_NAME_IEC958_MASK "Mask" +-#define SNDRV_CTL_NAME_IEC958_CON_MASK "Con Mask" +-#define SNDRV_CTL_NAME_IEC958_PRO_MASK "Pro Mask" +-#define SNDRV_CTL_NAME_IEC958_PCM_STREAM "PCM Stream" +-#define SNDRV_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what +- +-#endif /* _UAPI__SOUND_ASOUND_H */ ++#include +diff --git a/include/sound/asound_fm.h b/include/sound/asound_fm.h +index 8471f404ff0b..3e5da4d0bf4e 100644 +--- a/include/sound/asound_fm.h ++++ b/include/sound/asound_fm.h +@@ -1,135 +1 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-#ifndef __SOUND_ASOUND_FM_H +-#define __SOUND_ASOUND_FM_H +- +-/* +- * Advanced Linux Sound Architecture - ALSA +- * +- * Interface file between ALSA driver & user space +- * Copyright (c) 1994-98 by Jaroslav Kysela , +- * 4Front Technologies +- * +- * Direct FM control +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +- * +- */ +- +-#define SNDRV_DM_FM_MODE_OPL2 0x00 +-#define SNDRV_DM_FM_MODE_OPL3 0x01 +- +-struct snd_dm_fm_info { +- unsigned char fm_mode; /* OPL mode, see SNDRV_DM_FM_MODE_XXX */ +- unsigned char rhythm; /* percussion mode flag */ +-}; +- +-/* +- * Data structure composing an FM "note" or sound event. +- */ +- +-struct snd_dm_fm_voice { +- unsigned char op; /* operator cell (0 or 1) */ +- unsigned char voice; /* FM voice (0 to 17) */ +- +- unsigned char am; /* amplitude modulation */ +- unsigned char vibrato; /* vibrato effect */ +- unsigned char do_sustain; /* sustain phase */ +- unsigned char kbd_scale; /* keyboard scaling */ +- unsigned char harmonic; /* 4 bits: harmonic and multiplier */ +- unsigned char scale_level; /* 2 bits: decrease output freq rises */ +- unsigned char volume; /* 6 bits: volume */ +- +- unsigned char attack; /* 4 bits: attack rate */ +- unsigned char decay; /* 4 bits: decay rate */ +- unsigned char sustain; /* 4 bits: sustain level */ +- unsigned char release; /* 4 bits: release rate */ +- +- unsigned char feedback; /* 3 bits: feedback for op0 */ +- unsigned char connection; /* 0 for serial, 1 for parallel */ +- unsigned char left; /* stereo left */ +- unsigned char right; /* stereo right */ +- unsigned char waveform; /* 3 bits: waveform shape */ +-}; +- +-/* +- * This describes an FM note by its voice, octave, frequency number (10bit) +- * and key on/off. +- */ +- +-struct snd_dm_fm_note { +- unsigned char voice; /* 0-17 voice channel */ +- unsigned char octave; /* 3 bits: what octave to play */ +- unsigned int fnum; /* 10 bits: frequency number */ +- unsigned char key_on; /* set for active, clear for silent */ +-}; +- +-/* +- * FM parameters that apply globally to all voices, and thus are not "notes" +- */ +- +-struct snd_dm_fm_params { +- unsigned char am_depth; /* amplitude modulation depth (1=hi) */ +- unsigned char vib_depth; /* vibrato depth (1=hi) */ +- unsigned char kbd_split; /* keyboard split */ +- unsigned char rhythm; /* percussion mode select */ +- +- /* This block is the percussion instrument data */ +- unsigned char bass; +- unsigned char snare; +- unsigned char tomtom; +- unsigned char cymbal; +- unsigned char hihat; +-}; +- +-/* +- * FM mode ioctl settings +- */ +- +-#define SNDRV_DM_FM_IOCTL_INFO _IOR('H', 0x20, struct snd_dm_fm_info) +-#define SNDRV_DM_FM_IOCTL_RESET _IO ('H', 0x21) +-#define SNDRV_DM_FM_IOCTL_PLAY_NOTE _IOW('H', 0x22, struct snd_dm_fm_note) +-#define SNDRV_DM_FM_IOCTL_SET_VOICE _IOW('H', 0x23, struct snd_dm_fm_voice) +-#define SNDRV_DM_FM_IOCTL_SET_PARAMS _IOW('H', 0x24, struct snd_dm_fm_params) +-#define SNDRV_DM_FM_IOCTL_SET_MODE _IOW('H', 0x25, int) +-/* for OPL3 only */ +-#define SNDRV_DM_FM_IOCTL_SET_CONNECTION _IOW('H', 0x26, int) +-/* SBI patch management */ +-#define SNDRV_DM_FM_IOCTL_CLEAR_PATCHES _IO ('H', 0x40) +- +-#define SNDRV_DM_FM_OSS_IOCTL_RESET 0x20 +-#define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE 0x21 +-#define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE 0x22 +-#define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS 0x23 +-#define SNDRV_DM_FM_OSS_IOCTL_SET_MODE 0x24 +-#define SNDRV_DM_FM_OSS_IOCTL_SET_OPL 0x25 +- +-/* +- * Patch Record - fixed size for write +- */ +- +-#define FM_KEY_SBI "SBI\032" +-#define FM_KEY_2OP "2OP\032" +-#define FM_KEY_4OP "4OP\032" +- +-struct sbi_patch { +- unsigned char prog; +- unsigned char bank; +- char key[4]; +- char name[25]; +- char extension[7]; +- unsigned char data[32]; +-}; +- +-#endif /* __SOUND_ASOUND_FM_H */ ++#include +diff --git a/include/sound/emu10k1.h b/include/sound/emu10k1.h +index 042c5a6f16ee..f06ecee51c2b 100644 +--- a/include/sound/emu10k1.h ++++ b/include/sound/emu10k1.h +@@ -1,381 +1,2 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-/* +- * Copyright (c) by Jaroslav Kysela , +- * Creative Labs, Inc. +- * Definitions for EMU10K1 (SB Live!) chips +- * +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +- * +- */ +-#ifndef _UAPI__SOUND_EMU10K1_H +-#define _UAPI__SOUND_EMU10K1_H +- +-#include +-#include +- +-/* +- * ---- FX8010 ---- +- */ +- +-#define EMU10K1_CARD_CREATIVE 0x00000000 +-#define EMU10K1_CARD_EMUAPS 0x00000001 +- +-#define EMU10K1_FX8010_PCM_COUNT 8 +- +-/* +- * Following definition is copied from linux/types.h to support compiling +- * this header file in userspace since they are not generally available for +- * uapi headers. +- */ +-#define __EMU10K1_DECLARE_BITMAP(name,bits) \ +- unsigned long name[(bits) / (sizeof(unsigned long) * 8)] +- +-/* instruction set */ +-#define iMAC0 0x00 /* R = A + (X * Y >> 31) ; saturation */ +-#define iMAC1 0x01 /* R = A + (-X * Y >> 31) ; saturation */ +-#define iMAC2 0x02 /* R = A + (X * Y >> 31) ; wraparound */ +-#define iMAC3 0x03 /* R = A + (-X * Y >> 31) ; wraparound */ +-#define iMACINT0 0x04 /* R = A + X * Y ; saturation */ +-#define iMACINT1 0x05 /* R = A + X * Y ; wraparound (31-bit) */ +-#define iACC3 0x06 /* R = A + X + Y ; saturation */ +-#define iMACMV 0x07 /* R = A, acc += X * Y >> 31 */ +-#define iANDXOR 0x08 /* R = (A & X) ^ Y */ +-#define iTSTNEG 0x09 /* R = (A >= Y) ? X : ~X */ +-#define iLIMITGE 0x0a /* R = (A >= Y) ? X : Y */ +-#define iLIMITLT 0x0b /* R = (A < Y) ? X : Y */ +-#define iLOG 0x0c /* R = linear_data, A (log_data), X (max_exp), Y (format_word) */ +-#define iEXP 0x0d /* R = log_data, A (linear_data), X (max_exp), Y (format_word) */ +-#define iINTERP 0x0e /* R = A + (X * (Y - A) >> 31) ; saturation */ +-#define iSKIP 0x0f /* R = A (cc_reg), X (count), Y (cc_test) */ +- +-/* GPRs */ +-#define FXBUS(x) (0x00 + (x)) /* x = 0x00 - 0x0f */ +-#define EXTIN(x) (0x10 + (x)) /* x = 0x00 - 0x0f */ +-#define EXTOUT(x) (0x20 + (x)) /* x = 0x00 - 0x0f physical outs -> FXWC low 16 bits */ +-#define FXBUS2(x) (0x30 + (x)) /* x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits */ +- /* NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 */ +- +-#define C_00000000 0x40 +-#define C_00000001 0x41 +-#define C_00000002 0x42 +-#define C_00000003 0x43 +-#define C_00000004 0x44 +-#define C_00000008 0x45 +-#define C_00000010 0x46 +-#define C_00000020 0x47 +-#define C_00000100 0x48 +-#define C_00010000 0x49 +-#define C_00080000 0x4a +-#define C_10000000 0x4b +-#define C_20000000 0x4c +-#define C_40000000 0x4d +-#define C_80000000 0x4e +-#define C_7fffffff 0x4f +-#define C_ffffffff 0x50 +-#define C_fffffffe 0x51 +-#define C_c0000000 0x52 +-#define C_4f1bbcdc 0x53 +-#define C_5a7ef9db 0x54 +-#define C_00100000 0x55 /* ?? */ +-#define GPR_ACCU 0x56 /* ACCUM, accumulator */ +-#define GPR_COND 0x57 /* CCR, condition register */ +-#define GPR_NOISE0 0x58 /* noise source */ +-#define GPR_NOISE1 0x59 /* noise source */ +-#define GPR_IRQ 0x5a /* IRQ register */ +-#define GPR_DBAC 0x5b /* TRAM Delay Base Address Counter */ +-#define GPR(x) (FXGPREGBASE + (x)) /* free GPRs: x = 0x00 - 0xff */ +-#define ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ +-#define ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ +-#define ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ +-#define ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ +- +-#define A_ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ +-#define A_ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ +-#define A_ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ +-#define A_ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ +-#define A_ITRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ +-#define A_ETRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ +- +-#define A_FXBUS(x) (0x00 + (x)) /* x = 0x00 - 0x3f FX buses */ +-#define A_EXTIN(x) (0x40 + (x)) /* x = 0x00 - 0x0f physical ins */ +-#define A_P16VIN(x) (0x50 + (x)) /* x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" */ +-#define A_EXTOUT(x) (0x60 + (x)) /* x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown */ +-#define A_FXBUS2(x) (0x80 + (x)) /* x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 */ +-#define A_EMU32OUTH(x) (0xa0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" - ??? */ +-#define A_EMU32OUTL(x) (0xb0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_1 - _F" - ??? */ +-#define A3_EMU32IN(x) (0x160 + (x)) /* x = 0x00 - 0x3f "EMU32_IN_00 - _3F" - Only when .device = 0x0008 */ +-#define A3_EMU32OUT(x) (0x1E0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_00 - _3F" - Only when .device = 0x0008 */ +-#define A_GPR(x) (A_FXGPREGBASE + (x)) +- +-/* cc_reg constants */ +-#define CC_REG_NORMALIZED C_00000001 +-#define CC_REG_BORROW C_00000002 +-#define CC_REG_MINUS C_00000004 +-#define CC_REG_ZERO C_00000008 +-#define CC_REG_SATURATE C_00000010 +-#define CC_REG_NONZERO C_00000100 +- +-/* FX buses */ +-#define FXBUS_PCM_LEFT 0x00 +-#define FXBUS_PCM_RIGHT 0x01 +-#define FXBUS_PCM_LEFT_REAR 0x02 +-#define FXBUS_PCM_RIGHT_REAR 0x03 +-#define FXBUS_MIDI_LEFT 0x04 +-#define FXBUS_MIDI_RIGHT 0x05 +-#define FXBUS_PCM_CENTER 0x06 +-#define FXBUS_PCM_LFE 0x07 +-#define FXBUS_PCM_LEFT_FRONT 0x08 +-#define FXBUS_PCM_RIGHT_FRONT 0x09 +-#define FXBUS_MIDI_REVERB 0x0c +-#define FXBUS_MIDI_CHORUS 0x0d +-#define FXBUS_PCM_LEFT_SIDE 0x0e +-#define FXBUS_PCM_RIGHT_SIDE 0x0f +-#define FXBUS_PT_LEFT 0x14 +-#define FXBUS_PT_RIGHT 0x15 +- +-/* Inputs */ +-#define EXTIN_AC97_L 0x00 /* AC'97 capture channel - left */ +-#define EXTIN_AC97_R 0x01 /* AC'97 capture channel - right */ +-#define EXTIN_SPDIF_CD_L 0x02 /* internal S/PDIF CD - onboard - left */ +-#define EXTIN_SPDIF_CD_R 0x03 /* internal S/PDIF CD - onboard - right */ +-#define EXTIN_ZOOM_L 0x04 /* Zoom Video I2S - left */ +-#define EXTIN_ZOOM_R 0x05 /* Zoom Video I2S - right */ +-#define EXTIN_TOSLINK_L 0x06 /* LiveDrive - TOSLink Optical - left */ +-#define EXTIN_TOSLINK_R 0x07 /* LiveDrive - TOSLink Optical - right */ +-#define EXTIN_LINE1_L 0x08 /* LiveDrive - Line/Mic 1 - left */ +-#define EXTIN_LINE1_R 0x09 /* LiveDrive - Line/Mic 1 - right */ +-#define EXTIN_COAX_SPDIF_L 0x0a /* LiveDrive - Coaxial S/PDIF - left */ +-#define EXTIN_COAX_SPDIF_R 0x0b /* LiveDrive - Coaxial S/PDIF - right */ +-#define EXTIN_LINE2_L 0x0c /* LiveDrive - Line/Mic 2 - left */ +-#define EXTIN_LINE2_R 0x0d /* LiveDrive - Line/Mic 2 - right */ +- +-/* Outputs */ +-#define EXTOUT_AC97_L 0x00 /* AC'97 playback channel - left */ +-#define EXTOUT_AC97_R 0x01 /* AC'97 playback channel - right */ +-#define EXTOUT_TOSLINK_L 0x02 /* LiveDrive - TOSLink Optical - left */ +-#define EXTOUT_TOSLINK_R 0x03 /* LiveDrive - TOSLink Optical - right */ +-#define EXTOUT_AC97_CENTER 0x04 /* SB Live 5.1 - center */ +-#define EXTOUT_AC97_LFE 0x05 /* SB Live 5.1 - LFE */ +-#define EXTOUT_HEADPHONE_L 0x06 /* LiveDrive - Headphone - left */ +-#define EXTOUT_HEADPHONE_R 0x07 /* LiveDrive - Headphone - right */ +-#define EXTOUT_REAR_L 0x08 /* Rear channel - left */ +-#define EXTOUT_REAR_R 0x09 /* Rear channel - right */ +-#define EXTOUT_ADC_CAP_L 0x0a /* ADC Capture buffer - left */ +-#define EXTOUT_ADC_CAP_R 0x0b /* ADC Capture buffer - right */ +-#define EXTOUT_MIC_CAP 0x0c /* MIC Capture buffer */ +-#define EXTOUT_AC97_REAR_L 0x0d /* SB Live 5.1 (c) 2003 - Rear Left */ +-#define EXTOUT_AC97_REAR_R 0x0e /* SB Live 5.1 (c) 2003 - Rear Right */ +-#define EXTOUT_ACENTER 0x11 /* Analog Center */ +-#define EXTOUT_ALFE 0x12 /* Analog LFE */ +- +-/* Audigy Inputs */ +-#define A_EXTIN_AC97_L 0x00 /* AC'97 capture channel - left */ +-#define A_EXTIN_AC97_R 0x01 /* AC'97 capture channel - right */ +-#define A_EXTIN_SPDIF_CD_L 0x02 /* digital CD left */ +-#define A_EXTIN_SPDIF_CD_R 0x03 /* digital CD left */ +-#define A_EXTIN_OPT_SPDIF_L 0x04 /* audigy drive Optical SPDIF - left */ +-#define A_EXTIN_OPT_SPDIF_R 0x05 /* right */ +-#define A_EXTIN_LINE2_L 0x08 /* audigy drive line2/mic2 - left */ +-#define A_EXTIN_LINE2_R 0x09 /* right */ +-#define A_EXTIN_ADC_L 0x0a /* Philips ADC - left */ +-#define A_EXTIN_ADC_R 0x0b /* right */ +-#define A_EXTIN_AUX2_L 0x0c /* audigy drive aux2 - left */ +-#define A_EXTIN_AUX2_R 0x0d /* - right */ +- +-/* Audigiy Outputs */ +-#define A_EXTOUT_FRONT_L 0x00 /* digital front left */ +-#define A_EXTOUT_FRONT_R 0x01 /* right */ +-#define A_EXTOUT_CENTER 0x02 /* digital front center */ +-#define A_EXTOUT_LFE 0x03 /* digital front lfe */ +-#define A_EXTOUT_HEADPHONE_L 0x04 /* headphone audigy drive left */ +-#define A_EXTOUT_HEADPHONE_R 0x05 /* right */ +-#define A_EXTOUT_REAR_L 0x06 /* digital rear left */ +-#define A_EXTOUT_REAR_R 0x07 /* right */ +-#define A_EXTOUT_AFRONT_L 0x08 /* analog front left */ +-#define A_EXTOUT_AFRONT_R 0x09 /* right */ +-#define A_EXTOUT_ACENTER 0x0a /* analog center */ +-#define A_EXTOUT_ALFE 0x0b /* analog LFE */ +-#define A_EXTOUT_ASIDE_L 0x0c /* analog side left - Audigy 2 ZS */ +-#define A_EXTOUT_ASIDE_R 0x0d /* right - Audigy 2 ZS */ +-#define A_EXTOUT_AREAR_L 0x0e /* analog rear left */ +-#define A_EXTOUT_AREAR_R 0x0f /* right */ +-#define A_EXTOUT_AC97_L 0x10 /* AC97 left (front) */ +-#define A_EXTOUT_AC97_R 0x11 /* right */ +-#define A_EXTOUT_ADC_CAP_L 0x16 /* ADC capture buffer left */ +-#define A_EXTOUT_ADC_CAP_R 0x17 /* right */ +-#define A_EXTOUT_MIC_CAP 0x18 /* Mic capture buffer */ +- +-/* Audigy constants */ +-#define A_C_00000000 0xc0 +-#define A_C_00000001 0xc1 +-#define A_C_00000002 0xc2 +-#define A_C_00000003 0xc3 +-#define A_C_00000004 0xc4 +-#define A_C_00000008 0xc5 +-#define A_C_00000010 0xc6 +-#define A_C_00000020 0xc7 +-#define A_C_00000100 0xc8 +-#define A_C_00010000 0xc9 +-#define A_C_00000800 0xca +-#define A_C_10000000 0xcb +-#define A_C_20000000 0xcc +-#define A_C_40000000 0xcd +-#define A_C_80000000 0xce +-#define A_C_7fffffff 0xcf +-#define A_C_ffffffff 0xd0 +-#define A_C_fffffffe 0xd1 +-#define A_C_c0000000 0xd2 +-#define A_C_4f1bbcdc 0xd3 +-#define A_C_5a7ef9db 0xd4 +-#define A_C_00100000 0xd5 +-#define A_GPR_ACCU 0xd6 /* ACCUM, accumulator */ +-#define A_GPR_COND 0xd7 /* CCR, condition register */ +-#define A_GPR_NOISE0 0xd8 /* noise source */ +-#define A_GPR_NOISE1 0xd9 /* noise source */ +-#define A_GPR_IRQ 0xda /* IRQ register */ +-#define A_GPR_DBAC 0xdb /* TRAM Delay Base Address Counter - internal */ +-#define A_GPR_DBACE 0xde /* TRAM Delay Base Address Counter - external */ +- +-/* definitions for debug register */ +-#define EMU10K1_DBG_ZC 0x80000000 /* zero tram counter */ +-#define EMU10K1_DBG_SATURATION_OCCURED 0x02000000 /* saturation control */ +-#define EMU10K1_DBG_SATURATION_ADDR 0x01ff0000 /* saturation address */ +-#define EMU10K1_DBG_SINGLE_STEP 0x00008000 /* single step mode */ +-#define EMU10K1_DBG_STEP 0x00004000 /* start single step */ +-#define EMU10K1_DBG_CONDITION_CODE 0x00003e00 /* condition code */ +-#define EMU10K1_DBG_SINGLE_STEP_ADDR 0x000001ff /* single step address */ +- +-/* tank memory address line */ +-#ifndef __KERNEL__ +-#define TANKMEMADDRREG_ADDR_MASK 0x000fffff /* 20 bit tank address field */ +-#define TANKMEMADDRREG_CLEAR 0x00800000 /* Clear tank memory */ +-#define TANKMEMADDRREG_ALIGN 0x00400000 /* Align read or write relative to tank access */ +-#define TANKMEMADDRREG_WRITE 0x00200000 /* Write to tank memory */ +-#define TANKMEMADDRREG_READ 0x00100000 /* Read from tank memory */ +-#endif +- +-struct snd_emu10k1_fx8010_info { +- unsigned int internal_tram_size; /* in samples */ +- unsigned int external_tram_size; /* in samples */ +- char fxbus_names[16][32]; /* names of FXBUSes */ +- char extin_names[16][32]; /* names of external inputs */ +- char extout_names[32][32]; /* names of external outputs */ +- unsigned int gpr_controls; /* count of GPR controls */ +-}; +- +-#define EMU10K1_GPR_TRANSLATION_NONE 0 +-#define EMU10K1_GPR_TRANSLATION_TABLE100 1 +-#define EMU10K1_GPR_TRANSLATION_BASS 2 +-#define EMU10K1_GPR_TRANSLATION_TREBLE 3 +-#define EMU10K1_GPR_TRANSLATION_ONOFF 4 +- +-struct snd_emu10k1_fx8010_control_gpr { +- struct snd_ctl_elem_id id; /* full control ID definition */ +- unsigned int vcount; /* visible count */ +- unsigned int count; /* count of GPR (1..16) */ +- unsigned short gpr[32]; /* GPR number(s) */ +- unsigned int value[32]; /* initial values */ +- unsigned int min; /* minimum range */ +- unsigned int max; /* maximum range */ +- unsigned int translation; /* translation type (EMU10K1_GPR_TRANSLATION*) */ +- const unsigned int *tlv; +-}; +- +-/* old ABI without TLV support */ +-struct snd_emu10k1_fx8010_control_old_gpr { +- struct snd_ctl_elem_id id; +- unsigned int vcount; +- unsigned int count; +- unsigned short gpr[32]; +- unsigned int value[32]; +- unsigned int min; +- unsigned int max; +- unsigned int translation; +-}; +- +-struct snd_emu10k1_fx8010_code { +- char name[128]; +- +- __EMU10K1_DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */ +- __u32 __user *gpr_map; /* initializers */ +- +- unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */ +- struct snd_emu10k1_fx8010_control_gpr __user *gpr_add_controls; /* GPR controls to add/replace */ +- +- unsigned int gpr_del_control_count; /* count of GPR controls to remove */ +- struct snd_ctl_elem_id __user *gpr_del_controls; /* IDs of GPR controls to remove */ +- +- unsigned int gpr_list_control_count; /* count of GPR controls to list */ +- unsigned int gpr_list_control_total; /* total count of GPR controls */ +- struct snd_emu10k1_fx8010_control_gpr __user *gpr_list_controls; /* listed GPR controls */ +- +- __EMU10K1_DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */ +- __u32 __user *tram_data_map; /* data initializers */ +- __u32 __user *tram_addr_map; /* map initializers */ +- +- __EMU10K1_DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */ +- __u32 __user *code; /* one instruction - 64 bits */ +-}; +- +-struct snd_emu10k1_fx8010_tram { +- unsigned int address; /* 31.bit == 1 -> external TRAM */ +- unsigned int size; /* size in samples (4 bytes) */ +- unsigned int *samples; /* pointer to samples (20-bit) */ +- /* NULL->clear memory */ +-}; +- +-struct snd_emu10k1_fx8010_pcm_rec { +- unsigned int substream; /* substream number */ +- unsigned int res1; /* reserved */ +- unsigned int channels; /* 16-bit channels count, zero = remove this substream */ +- unsigned int tram_start; /* ring buffer position in TRAM (in samples) */ +- unsigned int buffer_size; /* count of buffered samples */ +- unsigned short gpr_size; /* GPR containing size of ringbuffer in samples (host) */ +- unsigned short gpr_ptr; /* GPR containing current pointer in the ring buffer (host = reset, FX8010) */ +- unsigned short gpr_count; /* GPR containing count of samples between two interrupts (host) */ +- unsigned short gpr_tmpcount; /* GPR containing current count of samples to interrupt (host = set, FX8010) */ +- unsigned short gpr_trigger; /* GPR containing trigger (activate) information (host) */ +- unsigned short gpr_running; /* GPR containing info if PCM is running (FX8010) */ +- unsigned char pad; /* reserved */ +- unsigned char etram[32]; /* external TRAM address & data (one per channel) */ +- unsigned int res2; /* reserved */ +-}; +- +-#define SNDRV_EMU10K1_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) +- +-#define SNDRV_EMU10K1_IOCTL_INFO _IOR ('H', 0x10, struct snd_emu10k1_fx8010_info) +-#define SNDRV_EMU10K1_IOCTL_CODE_POKE _IOW ('H', 0x11, struct snd_emu10k1_fx8010_code) +-#define SNDRV_EMU10K1_IOCTL_CODE_PEEK _IOWR('H', 0x12, struct snd_emu10k1_fx8010_code) +-#define SNDRV_EMU10K1_IOCTL_TRAM_SETUP _IOW ('H', 0x20, int) +-#define SNDRV_EMU10K1_IOCTL_TRAM_POKE _IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram) +-#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK _IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram) +-#define SNDRV_EMU10K1_IOCTL_PCM_POKE _IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec) +-#define SNDRV_EMU10K1_IOCTL_PCM_PEEK _IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec) +-#define SNDRV_EMU10K1_IOCTL_PVERSION _IOR ('H', 0x40, int) +-#define SNDRV_EMU10K1_IOCTL_STOP _IO ('H', 0x80) +-#define SNDRV_EMU10K1_IOCTL_CONTINUE _IO ('H', 0x81) +-#define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82) +-#define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int) +-#define SNDRV_EMU10K1_IOCTL_DBG_READ _IOR ('H', 0x84, int) +- +-/* typedefs for compatibility to user-space */ +-typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t; +-typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t; +-typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t; +-typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t; +-typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t; +- +-#endif /* _UAPI__SOUND_EMU10K1_H */ ++#include ++#include +diff --git a/include/sound/hdsp.h b/include/sound/hdsp.h +index 5dc0c3db0a4c..78fb745b607a 100644 +--- a/include/sound/hdsp.h ++++ b/include/sound/hdsp.h +@@ -1,111 +1,2 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-#ifndef __SOUND_HDSP_H +-#define __SOUND_HDSP_H +- +-/* +- * Copyright (C) 2003 Thomas Charbonnel (thomas@undata.org) +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +- */ +- +-#include +- +-#define HDSP_MATRIX_MIXER_SIZE 2048 +- +-enum HDSP_IO_Type { +- Digiface, +- Multiface, +- H9652, +- H9632, +- RPM, +- Undefined, +-}; +- +-struct hdsp_peak_rms { +- __u32 input_peaks[26]; +- __u32 playback_peaks[26]; +- __u32 output_peaks[28]; +- __u64 input_rms[26]; +- __u64 playback_rms[26]; +- /* These are only used for H96xx cards */ +- __u64 output_rms[26]; +-}; +- +-#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms) +- +-struct hdsp_config_info { +- unsigned char pref_sync_ref; +- unsigned char wordclock_sync_check; +- unsigned char spdif_sync_check; +- unsigned char adatsync_sync_check; +- unsigned char adat_sync_check[3]; +- unsigned char spdif_in; +- unsigned char spdif_out; +- unsigned char spdif_professional; +- unsigned char spdif_emphasis; +- unsigned char spdif_nonaudio; +- unsigned int spdif_sample_rate; +- unsigned int system_sample_rate; +- unsigned int autosync_sample_rate; +- unsigned char system_clock_mode; +- unsigned char clock_source; +- unsigned char autosync_ref; +- unsigned char line_out; +- unsigned char passthru; +- unsigned char da_gain; +- unsigned char ad_gain; +- unsigned char phone_gain; +- unsigned char xlr_breakout_cable; +- unsigned char analog_extension_board; +-}; +- +-#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info) +- +-struct hdsp_firmware { +- void __user *firmware_data; /* 24413 x 4 bytes */ +-}; +- +-#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware) +- +-struct hdsp_version { +- enum HDSP_IO_Type io_type; +- unsigned short firmware_rev; +-}; +- +-#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version) +- +-struct hdsp_mixer { +- unsigned short matrix[HDSP_MATRIX_MIXER_SIZE]; +-}; +- +-#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer) +- +-struct hdsp_9632_aeb { +- int aebi; +- int aebo; +-}; +- +-#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb) +- +-/* typedefs for compatibility to user-space */ +-typedef enum HDSP_IO_Type HDSP_IO_Type; +-typedef struct hdsp_peak_rms hdsp_peak_rms_t; +-typedef struct hdsp_config_info hdsp_config_info_t; +-typedef struct hdsp_firmware hdsp_firmware_t; +-typedef struct hdsp_version hdsp_version_t; +-typedef struct hdsp_mixer hdsp_mixer_t; +-typedef struct hdsp_9632_aeb hdsp_9632_aeb_t; +- +-#endif /* __SOUND_HDSP_H */ ++#include ++#include +diff --git a/include/sound/hdspm.h b/include/sound/hdspm.h +index a38f3f79beb7..af6d19eda87f 100644 +--- a/include/sound/hdspm.h ++++ b/include/sound/hdspm.h +@@ -1,232 +1,2 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-#ifndef __SOUND_HDSPM_H +-#define __SOUND_HDSPM_H +-/* +- * Copyright (C) 2003 Winfried Ritsch (IEM) +- * based on hdsp.h from Thomas Charbonnel (thomas@undata.org) +- * +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +- */ +- +-#include +- +-/* Maximum channels is 64 even on 56Mode you have 64playbacks to matrix */ +-#define HDSPM_MAX_CHANNELS 64 +- +-enum hdspm_io_type { +- MADI, +- MADIface, +- AIO, +- AES32, +- RayDAT +-}; +- +-enum hdspm_speed { +- ss, +- ds, +- qs +-}; +- +-/* -------------------- IOCTL Peak/RMS Meters -------------------- */ +- +-struct hdspm_peak_rms { +- __u32 input_peaks[64]; +- __u32 playback_peaks[64]; +- __u32 output_peaks[64]; +- +- __u64 input_rms[64]; +- __u64 playback_rms[64]; +- __u64 output_rms[64]; +- +- __u8 speed; /* enum {ss, ds, qs} */ +- int status2; +-}; +- +-#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS \ +- _IOR('H', 0x42, struct hdspm_peak_rms) +- +-/* ------------ CONFIG block IOCTL ---------------------- */ +- +-struct hdspm_config { +- unsigned char pref_sync_ref; +- unsigned char wordclock_sync_check; +- unsigned char madi_sync_check; +- unsigned int system_sample_rate; +- unsigned int autosync_sample_rate; +- unsigned char system_clock_mode; +- unsigned char clock_source; +- unsigned char autosync_ref; +- unsigned char line_out; +- unsigned int passthru; +- unsigned int analog_out; +-}; +- +-#define SNDRV_HDSPM_IOCTL_GET_CONFIG \ +- _IOR('H', 0x41, struct hdspm_config) +- +-/* +- * If there's a TCO (TimeCode Option) board installed, +- * there are further options and status data available. +- * The hdspm_ltc structure contains the current SMPTE +- * timecode and some status information and can be +- * obtained via SNDRV_HDSPM_IOCTL_GET_LTC or in the +- * hdspm_status struct. +- */ +- +-enum hdspm_ltc_format { +- format_invalid, +- fps_24, +- fps_25, +- fps_2997, +- fps_30 +-}; +- +-enum hdspm_ltc_frame { +- frame_invalid, +- drop_frame, +- full_frame +-}; +- +-enum hdspm_ltc_input_format { +- ntsc, +- pal, +- no_video +-}; +- +-struct hdspm_ltc { +- unsigned int ltc; +- +- enum hdspm_ltc_format format; +- enum hdspm_ltc_frame frame; +- enum hdspm_ltc_input_format input_format; +-}; +- +-#define SNDRV_HDSPM_IOCTL_GET_LTC _IOR('H', 0x46, struct hdspm_ltc) +- +-/* +- * The status data reflects the device's current state +- * as determined by the card's configuration and +- * connection status. +- */ +- +-enum hdspm_sync { +- hdspm_sync_no_lock = 0, +- hdspm_sync_lock = 1, +- hdspm_sync_sync = 2 +-}; +- +-enum hdspm_madi_input { +- hdspm_input_optical = 0, +- hdspm_input_coax = 1 +-}; +- +-enum hdspm_madi_channel_format { +- hdspm_format_ch_64 = 0, +- hdspm_format_ch_56 = 1 +-}; +- +-enum hdspm_madi_frame_format { +- hdspm_frame_48 = 0, +- hdspm_frame_96 = 1 +-}; +- +-enum hdspm_syncsource { +- syncsource_wc = 0, +- syncsource_madi = 1, +- syncsource_tco = 2, +- syncsource_sync = 3, +- syncsource_none = 4 +-}; +- +-struct hdspm_status { +- __u8 card_type; /* enum hdspm_io_type */ +- enum hdspm_syncsource autosync_source; +- +- __u64 card_clock; +- __u32 master_period; +- +- union { +- struct { +- __u8 sync_wc; /* enum hdspm_sync */ +- __u8 sync_madi; /* enum hdspm_sync */ +- __u8 sync_tco; /* enum hdspm_sync */ +- __u8 sync_in; /* enum hdspm_sync */ +- __u8 madi_input; /* enum hdspm_madi_input */ +- __u8 channel_format; /* enum hdspm_madi_channel_format */ +- __u8 frame_format; /* enum hdspm_madi_frame_format */ +- } madi; +- } card_specific; +-}; +- +-#define SNDRV_HDSPM_IOCTL_GET_STATUS \ +- _IOR('H', 0x47, struct hdspm_status) +- +-/* +- * Get information about the card and its add-ons. +- */ +- +-#define HDSPM_ADDON_TCO 1 +- +-struct hdspm_version { +- __u8 card_type; /* enum hdspm_io_type */ +- char cardname[20]; +- unsigned int serial; +- unsigned short firmware_rev; +- int addons; +-}; +- +-#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x48, struct hdspm_version) +- +-/* ------------- get Matrix Mixer IOCTL --------------- */ +- +-/* MADI mixer: 64inputs+64playback in 64outputs = 8192 => *4Byte = +- * 32768 Bytes +- */ +- +-/* organisation is 64 channelfader in a continuous memory block */ +-/* equivalent to hardware definition, maybe for future feature of mmap of +- * them +- */ +-/* each of 64 outputs has 64 infader and 64 outfader: +- Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] */ +- +-#define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS +- +-struct hdspm_channelfader { +- unsigned int in[HDSPM_MIXER_CHANNELS]; +- unsigned int pb[HDSPM_MIXER_CHANNELS]; +-}; +- +-struct hdspm_mixer { +- struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS]; +-}; +- +-struct hdspm_mixer_ioctl { +- struct hdspm_mixer *mixer; +-}; +- +-/* use indirect access due to the limit of ioctl bit size */ +-#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl) +- +-/* typedefs for compatibility to user-space */ +-typedef struct hdspm_peak_rms hdspm_peak_rms_t; +-typedef struct hdspm_config_info hdspm_config_info_t; +-typedef struct hdspm_version hdspm_version_t; +-typedef struct hdspm_channelfader snd_hdspm_channelfader_t; +-typedef struct hdspm_mixer hdspm_mixer_t; +- +- +-#endif ++#include ++#include +diff --git a/include/sound/sb16_csp.h b/include/sound/sb16_csp.h +index e64851481d88..24121fcbd888 100644 +--- a/include/sound/sb16_csp.h ++++ b/include/sound/sb16_csp.h +@@ -1,123 +1 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-/* +- * Copyright (c) 1999 by Uros Bizjak +- * Takashi Iwai +- * +- * SB16ASP/AWE32 CSP control +- * +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- * +- * You should have received a copy of the GNU General Public License +- * along with this program; if not, write to the Free Software +- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +- * +- */ +-#ifndef _UAPI__SOUND_SB16_CSP_H +-#define _UAPI__SOUND_SB16_CSP_H +- +- +-/* CSP modes */ +-#define SNDRV_SB_CSP_MODE_NONE 0x00 +-#define SNDRV_SB_CSP_MODE_DSP_READ 0x01 /* Record from DSP */ +-#define SNDRV_SB_CSP_MODE_DSP_WRITE 0x02 /* Play to DSP */ +-#define SNDRV_SB_CSP_MODE_QSOUND 0x04 /* QSound */ +- +-/* CSP load flags */ +-#define SNDRV_SB_CSP_LOAD_FROMUSER 0x01 +-#define SNDRV_SB_CSP_LOAD_INITBLOCK 0x02 +- +-/* CSP sample width */ +-#define SNDRV_SB_CSP_SAMPLE_8BIT 0x01 +-#define SNDRV_SB_CSP_SAMPLE_16BIT 0x02 +- +-/* CSP channels */ +-#define SNDRV_SB_CSP_MONO 0x01 +-#define SNDRV_SB_CSP_STEREO 0x02 +- +-/* CSP rates */ +-#define SNDRV_SB_CSP_RATE_8000 0x01 +-#define SNDRV_SB_CSP_RATE_11025 0x02 +-#define SNDRV_SB_CSP_RATE_22050 0x04 +-#define SNDRV_SB_CSP_RATE_44100 0x08 +-#define SNDRV_SB_CSP_RATE_ALL 0x0f +- +-/* CSP running state */ +-#define SNDRV_SB_CSP_ST_IDLE 0x00 +-#define SNDRV_SB_CSP_ST_LOADED 0x01 +-#define SNDRV_SB_CSP_ST_RUNNING 0x02 +-#define SNDRV_SB_CSP_ST_PAUSED 0x04 +-#define SNDRV_SB_CSP_ST_AUTO 0x08 +-#define SNDRV_SB_CSP_ST_QSOUND 0x10 +- +-/* maximum QSound value (180 degrees right) */ +-#define SNDRV_SB_CSP_QSOUND_MAX_RIGHT 0x20 +- +-/* maximum microcode RIFF file size */ +-#define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE 0x3000 +- +-/* microcode header */ +-struct snd_sb_csp_mc_header { +- char codec_name[16]; /* id name of codec */ +- unsigned short func_req; /* requested function */ +-}; +- +-/* microcode to be loaded */ +-struct snd_sb_csp_microcode { +- struct snd_sb_csp_mc_header info; +- unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE]; +-}; +- +-/* start CSP with sample_width in mono/stereo */ +-struct snd_sb_csp_start { +- int sample_width; /* sample width, look above */ +- int channels; /* channels, look above */ +-}; +- +-/* CSP information */ +-struct snd_sb_csp_info { +- char codec_name[16]; /* id name of codec */ +- unsigned short func_nr; /* function number */ +- unsigned int acc_format; /* accepted PCM formats */ +- unsigned short acc_channels; /* accepted channels */ +- unsigned short acc_width; /* accepted sample width */ +- unsigned short acc_rates; /* accepted sample rates */ +- unsigned short csp_mode; /* CSP mode, see above */ +- unsigned short run_channels; /* current channels */ +- unsigned short run_width; /* current sample width */ +- unsigned short version; /* version id: 0x10 - 0x1f */ +- unsigned short state; /* state bits */ +-}; +- +-/* HWDEP controls */ +-/* get CSP information */ +-#define SNDRV_SB_CSP_IOCTL_INFO _IOR('H', 0x10, struct snd_sb_csp_info) +-/* load microcode to CSP */ +-/* NOTE: struct snd_sb_csp_microcode overflows the max size (13 bits) +- * defined for some architectures like MIPS, and it leads to build errors. +- * (x86 and co have 14-bit size, thus it's valid, though.) +- * As a workaround for skipping the size-limit check, here we don't use the +- * normal _IOW() macro but _IOC() with the manual argument. +- */ +-#define SNDRV_SB_CSP_IOCTL_LOAD_CODE \ +- _IOC(_IOC_WRITE, 'H', 0x11, sizeof(struct snd_sb_csp_microcode)) +-/* unload microcode from CSP */ +-#define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE _IO('H', 0x12) +-/* start CSP */ +-#define SNDRV_SB_CSP_IOCTL_START _IOW('H', 0x13, struct snd_sb_csp_start) +-/* stop CSP */ +-#define SNDRV_SB_CSP_IOCTL_STOP _IO('H', 0x14) +-/* pause CSP and DMA transfer */ +-#define SNDRV_SB_CSP_IOCTL_PAUSE _IO('H', 0x15) +-/* restart CSP and DMA transfer */ +-#define SNDRV_SB_CSP_IOCTL_RESTART _IO('H', 0x16) +- +- +-#endif /* _UAPI__SOUND_SB16_CSP_H */ ++#include +diff --git a/include/sound/sscape_ioctl.h b/include/sound/sscape_ioctl.h +index c6653ebfb2c4..23b48d3364a9 100644 +--- a/include/sound/sscape_ioctl.h ++++ b/include/sound/sscape_ioctl.h +@@ -1,21 +1 @@ +-#ifndef SSCAPE_IOCTL_H +-#define SSCAPE_IOCTL_H +- +- +-struct sscape_bootblock +-{ +- unsigned char code[256]; +- unsigned version; +-}; +- +-#define SSCAPE_MICROCODE_SIZE 65536 +- +-struct sscape_microcode +-{ +- unsigned char *code; +-}; +- +-#define SND_SSCAPE_LOAD_BOOTB _IOWR('P', 100, struct sscape_bootblock) +-#define SND_SSCAPE_LOAD_MCODE _IOW ('P', 101, struct sscape_microcode) +- +-#endif ++#include +diff --git a/include/sound/tlv.h b/include/sound/tlv.h +index 7d6d65f60a42..e435a5fcb996 100644 +--- a/include/sound/tlv.h ++++ b/include/sound/tlv.h +@@ -1,117 +1 @@ +-/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ +-/* +- * This program is free software; you can redistribute it and/or modify +- * it under the terms of the GNU General Public License as published by +- * the Free Software Foundation; either version 2 of the License, or +- * (at your option) any later version. +- * +- * This program is distributed in the hope that it will be useful, +- * but WITHOUT ANY WARRANTY; without even the implied warranty of +- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- * GNU General Public License for more details. +- */ +- +-#ifndef __UAPI_SOUND_TLV_H +-#define __UAPI_SOUND_TLV_H +- +-#define SNDRV_CTL_TLVT_CONTAINER 0 /* one level down - group of TLVs */ +-#define SNDRV_CTL_TLVT_DB_SCALE 1 /* dB scale */ +-#define SNDRV_CTL_TLVT_DB_LINEAR 2 /* linear volume */ +-#define SNDRV_CTL_TLVT_DB_RANGE 3 /* dB range container */ +-#define SNDRV_CTL_TLVT_DB_MINMAX 4 /* dB scale with min/max */ +-#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */ +- +-/* +- * channel-mapping TLV items +- * TLV length must match with num_channels +- */ +-#define SNDRV_CTL_TLVT_CHMAP_FIXED 0x101 /* fixed channel position */ +-#define SNDRV_CTL_TLVT_CHMAP_VAR 0x102 /* channels freely swappable */ +-#define SNDRV_CTL_TLVT_CHMAP_PAIRED 0x103 /* pair-wise swappable */ +- +-/* +- * TLV structure is right behind the struct snd_ctl_tlv: +- * unsigned int type - see SNDRV_CTL_TLVT_* +- * unsigned int length +- * .... data aligned to sizeof(unsigned int), use +- * block_length = (length + (sizeof(unsigned int) - 1)) & +- * ~(sizeof(unsigned int) - 1)) .... +- */ +-#define SNDRV_CTL_TLVD_ITEM(type, ...) \ +- (type), SNDRV_CTL_TLVD_LENGTH(__VA_ARGS__), __VA_ARGS__ +-#define SNDRV_CTL_TLVD_LENGTH(...) \ +- ((unsigned int)sizeof((const unsigned int[]) { __VA_ARGS__ })) +- +-/* Accessor offsets for TLV data items */ +-#define SNDRV_CTL_TLVO_TYPE 0 +-#define SNDRV_CTL_TLVO_LEN 1 +- +-#define SNDRV_CTL_TLVD_CONTAINER_ITEM(...) \ +- SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_CONTAINER, __VA_ARGS__) +-#define SNDRV_CTL_TLVD_DECLARE_CONTAINER(name, ...) \ +- unsigned int name[] = { \ +- SNDRV_CTL_TLVD_CONTAINER_ITEM(__VA_ARGS__) \ +- } +- +-#define SNDRV_CTL_TLVD_DB_SCALE_MASK 0xffff +-#define SNDRV_CTL_TLVD_DB_SCALE_MUTE 0x10000 +-#define SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ +- SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_SCALE, \ +- (min), \ +- ((step) & SNDRV_CTL_TLVD_DB_SCALE_MASK) | \ +- ((mute) ? SNDRV_CTL_TLVD_DB_SCALE_MUTE : 0)) +-#define SNDRV_CTL_TLVD_DECLARE_DB_SCALE(name, min, step, mute) \ +- unsigned int name[] = { \ +- SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ +- } +- +-/* Accessor offsets for min, mute and step items in dB scale type TLV */ +-#define SNDRV_CTL_TLVO_DB_SCALE_MIN 2 +-#define SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP 3 +- +-/* dB scale specified with min/max values instead of step */ +-#define SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ +- SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX, (min_dB), (max_dB)) +-#define SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ +- SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX_MUTE, (min_dB), (max_dB)) +-#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(name, min_dB, max_dB) \ +- unsigned int name[] = { \ +- SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ +- } +-#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE(name, min_dB, max_dB) \ +- unsigned int name[] = { \ +- SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ +- } +- +-/* Accessor offsets for min, max items in db-minmax types of TLV. */ +-#define SNDRV_CTL_TLVO_DB_MINMAX_MIN 2 +-#define SNDRV_CTL_TLVO_DB_MINMAX_MAX 3 +- +-/* linear volume between min_dB and max_dB (.01dB unit) */ +-#define SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ +- SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_LINEAR, (min_dB), (max_dB)) +-#define SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(name, min_dB, max_dB) \ +- unsigned int name[] = { \ +- SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ +- } +- +-/* Accessor offsets for min, max items in db-linear type of TLV. */ +-#define SNDRV_CTL_TLVO_DB_LINEAR_MIN 2 +-#define SNDRV_CTL_TLVO_DB_LINEAR_MAX 3 +- +-/* dB range container: +- * Items in dB range container must be ordered by their values and by their +- * dB values. This implies that larger values must correspond with larger +- * dB values (which is also required for all other mixer controls). +- */ +-/* Each item is: */ +-#define SNDRV_CTL_TLVD_DB_RANGE_ITEM(...) \ +- SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_RANGE, __VA_ARGS__) +-#define SNDRV_CTL_TLVD_DECLARE_DB_RANGE(name, ...) \ +- unsigned int name[] = { \ +- SNDRV_CTL_TLVD_DB_RANGE_ITEM(__VA_ARGS__) \ +- } +- +-#define SNDRV_CTL_TLVD_DB_GAIN_MUTE -9999999 +- +-#endif ++#include +diff --git a/include/sound/type_compat.h b/include/sound/type_compat.h +index e973ff3139e2..d4790c1f0e64 100644 +--- a/include/sound/type_compat.h ++++ b/include/sound/type_compat.h +@@ -3,6 +3,9 @@ + + #ifndef DOC_HIDDEN + #include ++#ifdef __linux__ ++#include ++#else + typedef uint8_t __u8; + typedef uint16_t __u16; + typedef uint32_t __u32; +@@ -37,6 +40,16 @@ typedef int32_t __s32; + #define __be32 __u32 + #define __be16 __u16 + #define __be8 __u8 ++#endif ++ ++#ifndef __user ++#define __user ++#endif ++ ++#ifndef __packed ++#define __packed __attribute__((__packed__)) ++#endif ++ + #endif /* DOC_HIDDEN */ + + #endif /* __TYPE_COMPAT_H */ +diff --git a/include/sound/uapi/Makefile.am b/include/sound/uapi/Makefile.am +new file mode 100644 +index 000000000000..99197108509e +--- /dev/null ++++ b/include/sound/uapi/Makefile.am +@@ -0,0 +1,6 @@ ++alsasounduapiincludedir = ${includedir}/alsa/sound/uapi ++ ++alsasounduapiinclude_HEADERS = asound_fm.h hdsp.h hdspm.h sb16_csp.h \ ++ sscape_ioctl.h emu10k1.h asoc.h tlv.h ++ ++noinst_HEADERS = asound.h asequencer.h +diff --git a/include/sound/uapi/asequencer.h b/include/sound/uapi/asequencer.h +new file mode 100644 +index 000000000000..a75e14edc957 +--- /dev/null ++++ b/include/sound/uapi/asequencer.h +@@ -0,0 +1,612 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++/* ++ * Main header file for the ALSA sequencer ++ * Copyright (c) 1998-1999 by Frank van de Pol ++ * (c) 1998-1999 by Jaroslav Kysela ++ * ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ */ ++#ifndef _UAPI__SOUND_ASEQUENCER_H ++#define _UAPI__SOUND_ASEQUENCER_H ++ ++#include ++ ++/** version of the sequencer */ ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++ ++/** ++ * definition of sequencer event types ++ */ ++ ++/** system messages ++ * event data type = #snd_seq_result ++ */ ++#define SNDRV_SEQ_EVENT_SYSTEM 0 ++#define SNDRV_SEQ_EVENT_RESULT 1 ++ ++/** note messages (channel specific) ++ * event data type = #snd_seq_ev_note ++ */ ++#define SNDRV_SEQ_EVENT_NOTE 5 ++#define SNDRV_SEQ_EVENT_NOTEON 6 ++#define SNDRV_SEQ_EVENT_NOTEOFF 7 ++#define SNDRV_SEQ_EVENT_KEYPRESS 8 ++ ++/** control messages (channel specific) ++ * event data type = #snd_seq_ev_ctrl ++ */ ++#define SNDRV_SEQ_EVENT_CONTROLLER 10 ++#define SNDRV_SEQ_EVENT_PGMCHANGE 11 ++#define SNDRV_SEQ_EVENT_CHANPRESS 12 ++#define SNDRV_SEQ_EVENT_PITCHBEND 13 /**< from -8192 to 8191 */ ++#define SNDRV_SEQ_EVENT_CONTROL14 14 /**< 14 bit controller value */ ++#define SNDRV_SEQ_EVENT_NONREGPARAM 15 /**< 14 bit NRPN address + 14 bit unsigned value */ ++#define SNDRV_SEQ_EVENT_REGPARAM 16 /**< 14 bit RPN address + 14 bit unsigned value */ ++ ++/** synchronisation messages ++ * event data type = #snd_seq_ev_ctrl ++ */ ++#define SNDRV_SEQ_EVENT_SONGPOS 20 /* Song Position Pointer with LSB and MSB values */ ++#define SNDRV_SEQ_EVENT_SONGSEL 21 /* Song Select with song ID number */ ++#define SNDRV_SEQ_EVENT_QFRAME 22 /* midi time code quarter frame */ ++#define SNDRV_SEQ_EVENT_TIMESIGN 23 /* SMF Time Signature event */ ++#define SNDRV_SEQ_EVENT_KEYSIGN 24 /* SMF Key Signature event */ ++ ++/** timer messages ++ * event data type = snd_seq_ev_queue_control ++ */ ++#define SNDRV_SEQ_EVENT_START 30 /* midi Real Time Start message */ ++#define SNDRV_SEQ_EVENT_CONTINUE 31 /* midi Real Time Continue message */ ++#define SNDRV_SEQ_EVENT_STOP 32 /* midi Real Time Stop message */ ++#define SNDRV_SEQ_EVENT_SETPOS_TICK 33 /* set tick queue position */ ++#define SNDRV_SEQ_EVENT_SETPOS_TIME 34 /* set realtime queue position */ ++#define SNDRV_SEQ_EVENT_TEMPO 35 /* (SMF) Tempo event */ ++#define SNDRV_SEQ_EVENT_CLOCK 36 /* midi Real Time Clock message */ ++#define SNDRV_SEQ_EVENT_TICK 37 /* midi Real Time Tick message */ ++#define SNDRV_SEQ_EVENT_QUEUE_SKEW 38 /* skew queue tempo */ ++ ++/** others ++ * event data type = none ++ */ ++#define SNDRV_SEQ_EVENT_TUNE_REQUEST 40 /* tune request */ ++#define SNDRV_SEQ_EVENT_RESET 41 /* reset to power-on state */ ++#define SNDRV_SEQ_EVENT_SENSING 42 /* "active sensing" event */ ++ ++/** echo back, kernel private messages ++ * event data type = any type ++ */ ++#define SNDRV_SEQ_EVENT_ECHO 50 /* echo event */ ++#define SNDRV_SEQ_EVENT_OSS 51 /* OSS raw event */ ++ ++/** system status messages (broadcast for subscribers) ++ * event data type = snd_seq_addr ++ */ ++#define SNDRV_SEQ_EVENT_CLIENT_START 60 /* new client has connected */ ++#define SNDRV_SEQ_EVENT_CLIENT_EXIT 61 /* client has left the system */ ++#define SNDRV_SEQ_EVENT_CLIENT_CHANGE 62 /* client status/info has changed */ ++#define SNDRV_SEQ_EVENT_PORT_START 63 /* new port was created */ ++#define SNDRV_SEQ_EVENT_PORT_EXIT 64 /* port was deleted from system */ ++#define SNDRV_SEQ_EVENT_PORT_CHANGE 65 /* port status/info has changed */ ++ ++/** port connection changes ++ * event data type = snd_seq_connect ++ */ ++#define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66 /* ports connected */ ++#define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67 /* ports disconnected */ ++ ++/* 70-89: synthesizer events - obsoleted */ ++ ++/** user-defined events with fixed length ++ * event data type = any ++ */ ++#define SNDRV_SEQ_EVENT_USR0 90 ++#define SNDRV_SEQ_EVENT_USR1 91 ++#define SNDRV_SEQ_EVENT_USR2 92 ++#define SNDRV_SEQ_EVENT_USR3 93 ++#define SNDRV_SEQ_EVENT_USR4 94 ++#define SNDRV_SEQ_EVENT_USR5 95 ++#define SNDRV_SEQ_EVENT_USR6 96 ++#define SNDRV_SEQ_EVENT_USR7 97 ++#define SNDRV_SEQ_EVENT_USR8 98 ++#define SNDRV_SEQ_EVENT_USR9 99 ++ ++/* 100-118: instrument layer - obsoleted */ ++/* 119-129: reserved */ ++ ++/* 130-139: variable length events ++ * event data type = snd_seq_ev_ext ++ * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set) ++ */ ++#define SNDRV_SEQ_EVENT_SYSEX 130 /* system exclusive data (variable length) */ ++#define SNDRV_SEQ_EVENT_BOUNCE 131 /* error event */ ++/* 132-134: reserved */ ++#define SNDRV_SEQ_EVENT_USR_VAR0 135 ++#define SNDRV_SEQ_EVENT_USR_VAR1 136 ++#define SNDRV_SEQ_EVENT_USR_VAR2 137 ++#define SNDRV_SEQ_EVENT_USR_VAR3 138 ++#define SNDRV_SEQ_EVENT_USR_VAR4 139 ++ ++/* 150-151: kernel events with quote - DO NOT use in user clients */ ++#define SNDRV_SEQ_EVENT_KERNEL_ERROR 150 ++#define SNDRV_SEQ_EVENT_KERNEL_QUOTE 151 /* obsolete */ ++ ++/* 152-191: reserved */ ++ ++/* 192-254: hardware specific events */ ++ ++/* 255: special event */ ++#define SNDRV_SEQ_EVENT_NONE 255 ++ ++ ++typedef unsigned char snd_seq_event_type_t; ++ ++/** event address */ ++struct snd_seq_addr { ++ unsigned char client; /**< Client number: 0..255, 255 = broadcast to all clients */ ++ unsigned char port; /**< Port within client: 0..255, 255 = broadcast to all ports */ ++}; ++ ++/** port connection */ ++struct snd_seq_connect { ++ struct snd_seq_addr sender; ++ struct snd_seq_addr dest; ++}; ++ ++ ++#define SNDRV_SEQ_ADDRESS_UNKNOWN 253 /* unknown source */ ++#define SNDRV_SEQ_ADDRESS_SUBSCRIBERS 254 /* send event to all subscribed ports */ ++#define SNDRV_SEQ_ADDRESS_BROADCAST 255 /* send event to all queues/clients/ports/channels */ ++#define SNDRV_SEQ_QUEUE_DIRECT 253 /* direct dispatch */ ++ ++ /* event mode flag - NOTE: only 8 bits available! */ ++#define SNDRV_SEQ_TIME_STAMP_TICK (0<<0) /* timestamp in clock ticks */ ++#define SNDRV_SEQ_TIME_STAMP_REAL (1<<0) /* timestamp in real time */ ++#define SNDRV_SEQ_TIME_STAMP_MASK (1<<0) ++ ++#define SNDRV_SEQ_TIME_MODE_ABS (0<<1) /* absolute timestamp */ ++#define SNDRV_SEQ_TIME_MODE_REL (1<<1) /* relative to current time */ ++#define SNDRV_SEQ_TIME_MODE_MASK (1<<1) ++ ++#define SNDRV_SEQ_EVENT_LENGTH_FIXED (0<<2) /* fixed event size */ ++#define SNDRV_SEQ_EVENT_LENGTH_VARIABLE (1<<2) /* variable event size */ ++#define SNDRV_SEQ_EVENT_LENGTH_VARUSR (2<<2) /* variable event size - user memory space */ ++#define SNDRV_SEQ_EVENT_LENGTH_MASK (3<<2) ++ ++#define SNDRV_SEQ_PRIORITY_NORMAL (0<<4) /* normal priority */ ++#define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ ++#define SNDRV_SEQ_PRIORITY_MASK (1<<4) ++ ++ ++ /* note event */ ++struct snd_seq_ev_note { ++ unsigned char channel; ++ unsigned char note; ++ unsigned char velocity; ++ unsigned char off_velocity; /* only for SNDRV_SEQ_EVENT_NOTE */ ++ unsigned int duration; /* only for SNDRV_SEQ_EVENT_NOTE */ ++}; ++ ++ /* controller event */ ++struct snd_seq_ev_ctrl { ++ unsigned char channel; ++ unsigned char unused1, unused2, unused3; /* pad */ ++ unsigned int param; ++ signed int value; ++}; ++ ++ /* generic set of bytes (12x8 bit) */ ++struct snd_seq_ev_raw8 { ++ unsigned char d[12]; /* 8 bit value */ ++}; ++ ++ /* generic set of integers (3x32 bit) */ ++struct snd_seq_ev_raw32 { ++ unsigned int d[3]; /* 32 bit value */ ++}; ++ ++ /* external stored data */ ++struct snd_seq_ev_ext { ++ unsigned int len; /* length of data */ ++ void *ptr; /* pointer to data (note: maybe 64-bit) */ ++} __attribute__((packed)); ++ ++struct snd_seq_result { ++ int event; /* processed event type */ ++ int result; ++}; ++ ++ ++struct snd_seq_real_time { ++ unsigned int tv_sec; /* seconds */ ++ unsigned int tv_nsec; /* nanoseconds */ ++}; ++ ++typedef unsigned int snd_seq_tick_time_t; /* midi ticks */ ++ ++union snd_seq_timestamp { ++ snd_seq_tick_time_t tick; ++ struct snd_seq_real_time time; ++}; ++ ++struct snd_seq_queue_skew { ++ unsigned int value; ++ unsigned int base; ++}; ++ ++ /* queue timer control */ ++struct snd_seq_ev_queue_control { ++ unsigned char queue; /* affected queue */ ++ unsigned char pad[3]; /* reserved */ ++ union { ++ signed int value; /* affected value (e.g. tempo) */ ++ union snd_seq_timestamp time; /* time */ ++ unsigned int position; /* sync position */ ++ struct snd_seq_queue_skew skew; ++ unsigned int d32[2]; ++ unsigned char d8[8]; ++ } param; ++}; ++ ++ /* quoted event - inside the kernel only */ ++struct snd_seq_ev_quote { ++ struct snd_seq_addr origin; /* original sender */ ++ unsigned short value; /* optional data */ ++ struct snd_seq_event *event; /* quoted event */ ++} __attribute__((packed)); ++ ++ ++ /* sequencer event */ ++struct snd_seq_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ ++ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++ } data; ++}; ++ ++ ++/* ++ * bounce event - stored as variable size data ++ */ ++struct snd_seq_event_bounce { ++ int err; ++ struct snd_seq_event event; ++ /* external data follows here. */ ++}; ++ ++ ++ /* system information */ ++struct snd_seq_system_info { ++ int queues; /* maximum queues count */ ++ int clients; /* maximum clients count */ ++ int ports; /* maximum ports per client */ ++ int channels; /* maximum channels per port */ ++ int cur_clients; /* current clients */ ++ int cur_queues; /* current queues */ ++ char reserved[24]; ++}; ++ ++ ++ /* system running information */ ++struct snd_seq_running_info { ++ unsigned char client; /* client id */ ++ unsigned char big_endian; /* 1 = big-endian */ ++ unsigned char cpu_mode; /* 4 = 32bit, 8 = 64bit */ ++ unsigned char pad; /* reserved */ ++ unsigned char reserved[12]; ++}; ++ ++ ++ /* known client numbers */ ++#define SNDRV_SEQ_CLIENT_SYSTEM 0 ++ /* internal client numbers */ ++#define SNDRV_SEQ_CLIENT_DUMMY 14 /* midi through */ ++#define SNDRV_SEQ_CLIENT_OSS 15 /* oss sequencer emulator */ ++ ++ ++ /* client types */ ++typedef int __bitwise snd_seq_client_type_t; ++#define NO_CLIENT ((__force snd_seq_client_type_t) 0) ++#define USER_CLIENT ((__force snd_seq_client_type_t) 1) ++#define KERNEL_CLIENT ((__force snd_seq_client_type_t) 2) ++ ++ /* event filter flags */ ++#define SNDRV_SEQ_FILTER_BROADCAST (1<<0) /* accept broadcast messages */ ++#define SNDRV_SEQ_FILTER_MULTICAST (1<<1) /* accept multicast messages */ ++#define SNDRV_SEQ_FILTER_BOUNCE (1<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_USE_EVENT (1<<31) /* use event filter */ ++ ++struct snd_seq_client_info { ++ int client; /* client number to inquire */ ++ snd_seq_client_type_t type; /* client type */ ++ char name[64]; /* client name */ ++ unsigned int filter; /* filter flags */ ++ unsigned char multicast_filter[8]; /* multicast filter bitmap */ ++ unsigned char event_filter[32]; /* event filter bitmap */ ++ int num_ports; /* RO: number of ports */ ++ int event_lost; /* number of lost events */ ++ int card; /* RO: card number[kernel] */ ++ int pid; /* RO: pid[user] */ ++ char reserved[56]; /* for future use */ ++}; ++ ++ ++/* client pool size */ ++struct snd_seq_client_pool { ++ int client; /* client number to inquire */ ++ int output_pool; /* outgoing (write) pool size */ ++ int input_pool; /* incoming (read) pool size */ ++ int output_room; /* minimum free pool size for select/blocking mode */ ++ int output_free; /* unused size */ ++ int input_free; /* unused size */ ++ char reserved[64]; ++}; ++ ++ ++/* Remove events by specified criteria */ ++ ++#define SNDRV_SEQ_REMOVE_INPUT (1<<0) /* Flush input queues */ ++#define SNDRV_SEQ_REMOVE_OUTPUT (1<<1) /* Flush output queues */ ++#define SNDRV_SEQ_REMOVE_DEST (1<<2) /* Restrict by destination q:client:port */ ++#define SNDRV_SEQ_REMOVE_DEST_CHANNEL (1<<3) /* Restrict by channel */ ++#define SNDRV_SEQ_REMOVE_TIME_BEFORE (1<<4) /* Restrict to before time */ ++#define SNDRV_SEQ_REMOVE_TIME_AFTER (1<<5) /* Restrict to time or after */ ++#define SNDRV_SEQ_REMOVE_TIME_TICK (1<<6) /* Time is in ticks */ ++#define SNDRV_SEQ_REMOVE_EVENT_TYPE (1<<7) /* Restrict to event type */ ++#define SNDRV_SEQ_REMOVE_IGNORE_OFF (1<<8) /* Do not flush off events */ ++#define SNDRV_SEQ_REMOVE_TAG_MATCH (1<<9) /* Restrict to events with given tag */ ++ ++struct snd_seq_remove_events { ++ unsigned int remove_mode; /* Flags that determine what gets removed */ ++ ++ union snd_seq_timestamp time; ++ ++ unsigned char queue; /* Queue for REMOVE_DEST */ ++ struct snd_seq_addr dest; /* Address for REMOVE_DEST */ ++ unsigned char channel; /* Channel for REMOVE_DEST */ ++ ++ int type; /* For REMOVE_EVENT_TYPE */ ++ char tag; /* Tag for REMOVE_TAG */ ++ ++ int reserved[10]; /* To allow for future binary compatibility */ ++ ++}; ++ ++ ++ /* known port numbers */ ++#define SNDRV_SEQ_PORT_SYSTEM_TIMER 0 ++#define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE 1 ++ ++ /* port capabilities (32 bits) */ ++#define SNDRV_SEQ_PORT_CAP_READ (1<<0) /* readable from this port */ ++#define SNDRV_SEQ_PORT_CAP_WRITE (1<<1) /* writable to this port */ ++ ++#define SNDRV_SEQ_PORT_CAP_SYNC_READ (1<<2) ++#define SNDRV_SEQ_PORT_CAP_SYNC_WRITE (1<<3) ++ ++#define SNDRV_SEQ_PORT_CAP_DUPLEX (1<<4) ++ ++#define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ ++#define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ ++#define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++ ++ /* port type */ ++#define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1) /* generic MIDI device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_GM (1<<2) /* General MIDI compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_GS (1<<3) /* GS compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++ ++/* other standards...*/ ++#define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ ++#define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11) /* Sampling device (support sample download) */ ++#define SNDRV_SEQ_PORT_TYPE_SAMPLE (1<<12) /* Sampling device (sample can be downloaded at any time) */ ++/*...*/ ++#define SNDRV_SEQ_PORT_TYPE_HARDWARE (1<<16) /* driver for a hardware device */ ++#define SNDRV_SEQ_PORT_TYPE_SOFTWARE (1<<17) /* implemented in software */ ++#define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER (1<<18) /* generates sound */ ++#define SNDRV_SEQ_PORT_TYPE_PORT (1<<19) /* connects to other device(s) */ ++#define SNDRV_SEQ_PORT_TYPE_APPLICATION (1<<20) /* application (sequencer/editor) */ ++ ++/* misc. conditioning flags */ ++#define SNDRV_SEQ_PORT_FLG_GIVEN_PORT (1<<0) ++#define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) ++#define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) ++ ++struct snd_seq_port_info { ++ struct snd_seq_addr addr; /* client/port numbers */ ++ char name[64]; /* port name */ ++ ++ unsigned int capability; /* port capability bits */ ++ unsigned int type; /* port type bits */ ++ int midi_channels; /* channels per MIDI port */ ++ int midi_voices; /* voices per MIDI port */ ++ int synth_voices; /* voices per SYNTH port */ ++ ++ int read_use; /* R/O: subscribers for output (from this port) */ ++ int write_use; /* R/O: subscribers for input (to this port) */ ++ ++ void *kernel; /* reserved for kernel use (must be NULL) */ ++ unsigned int flags; /* misc. conditioning */ ++ unsigned char time_queue; /* queue # for timestamping */ ++ char reserved[59]; /* for future use */ ++}; ++ ++ ++/* queue flags */ ++#define SNDRV_SEQ_QUEUE_FLG_SYNC (1<<0) /* sync enabled */ ++ ++/* queue information */ ++struct snd_seq_queue_info { ++ int queue; /* queue id */ ++ ++ /* ++ * security settings, only owner of this queue can start/stop timer ++ * etc. if the queue is locked for other clients ++ */ ++ int owner; /* client id for owner of the queue */ ++ unsigned locked:1; /* timing queue locked for other queues */ ++ char name[64]; /* name of this queue */ ++ unsigned int flags; /* flags */ ++ char reserved[60]; /* for future use */ ++ ++}; ++ ++/* queue info/status */ ++struct snd_seq_queue_status { ++ int queue; /* queue id */ ++ int events; /* read-only - queue size */ ++ snd_seq_tick_time_t tick; /* current tick */ ++ struct snd_seq_real_time time; /* current time */ ++ int running; /* running state of queue */ ++ int flags; /* various flags */ ++ char reserved[64]; /* for the future */ ++}; ++ ++ ++/* queue tempo */ ++struct snd_seq_queue_tempo { ++ int queue; /* sequencer queue */ ++ unsigned int tempo; /* current tempo, us/tick */ ++ int ppq; /* time resolution, ticks/quarter */ ++ unsigned int skew_value; /* queue skew */ ++ unsigned int skew_base; /* queue skew base */ ++ char reserved[24]; /* for the future */ ++}; ++ ++ ++/* sequencer timer sources */ ++#define SNDRV_SEQ_TIMER_ALSA 0 /* ALSA timer */ ++#define SNDRV_SEQ_TIMER_MIDI_CLOCK 1 /* Midi Clock (CLOCK event) */ ++#define SNDRV_SEQ_TIMER_MIDI_TICK 2 /* Midi Timer Tick (TICK event) */ ++ ++/* queue timer info */ ++struct snd_seq_queue_timer { ++ int queue; /* sequencer queue */ ++ int type; /* source timer type */ ++ union { ++ struct { ++ struct snd_timer_id id; /* ALSA's timer ID */ ++ unsigned int resolution; /* resolution in Hz */ ++ } alsa; ++ } u; ++ char reserved[64]; /* for the future use */ ++}; ++ ++ ++struct snd_seq_queue_client { ++ int queue; /* sequencer queue */ ++ int client; /* sequencer client */ ++ int used; /* queue is used with this client ++ (must be set for accepting events) */ ++ /* per client watermarks */ ++ char reserved[64]; /* for future use */ ++}; ++ ++ ++#define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE (1<<0) /* exclusive connection */ ++#define SNDRV_SEQ_PORT_SUBS_TIMESTAMP (1<<1) ++#define SNDRV_SEQ_PORT_SUBS_TIME_REAL (1<<2) ++ ++struct snd_seq_port_subscribe { ++ struct snd_seq_addr sender; /* sender address */ ++ struct snd_seq_addr dest; /* destination address */ ++ unsigned int voices; /* number of voices to be allocated (0 = don't care) */ ++ unsigned int flags; /* modes */ ++ unsigned char queue; /* input time-stamp queue (optional) */ ++ unsigned char pad[3]; /* reserved */ ++ char reserved[64]; ++}; ++ ++/* type of query subscription */ ++#define SNDRV_SEQ_QUERY_SUBS_READ 0 ++#define SNDRV_SEQ_QUERY_SUBS_WRITE 1 ++ ++struct snd_seq_query_subs { ++ struct snd_seq_addr root; /* client/port id to be searched */ ++ int type; /* READ or WRITE */ ++ int index; /* 0..N-1 */ ++ int num_subs; /* R/O: number of subscriptions on this port */ ++ struct snd_seq_addr addr; /* R/O: result */ ++ unsigned char queue; /* R/O: result */ ++ unsigned int flags; /* R/O: result */ ++ char reserved[64]; /* for future use */ ++}; ++ ++ ++/* ++ * IOCTL commands ++ */ ++ ++#define SNDRV_SEQ_IOCTL_PVERSION _IOR ('S', 0x00, int) ++#define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) ++#define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) ++#define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++ ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++ ++#define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) ++#define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) ++#define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct snd_seq_port_info) ++#define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct snd_seq_port_info) ++ ++#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct snd_seq_port_subscribe) ++#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe) ++ ++#define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct snd_seq_queue_info) ++#define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct snd_seq_queue_info) ++#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct snd_seq_queue_info) ++#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct snd_seq_queue_info) ++#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info) ++#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status) ++#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo) ++#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo) ++#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer) ++#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer) ++#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct snd_seq_queue_client) ++#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct snd_seq_queue_client) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool) ++#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct snd_seq_remove_events) ++#define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct snd_seq_query_subs) ++#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct snd_seq_port_subscribe) ++#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info) ++ ++#endif /* _UAPI__SOUND_ASEQUENCER_H */ +diff --git a/include/sound/uapi/asoc.h b/include/sound/uapi/asoc.h +new file mode 100644 +index 000000000000..a74ca232f1fc +--- /dev/null ++++ b/include/sound/uapi/asoc.h +@@ -0,0 +1,633 @@ ++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ ++/* ++ * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM ++ * ++ * Copyright (C) 2012 Texas Instruments Inc. ++ * Copyright (C) 2015 Intel Corporation. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Simple file API to load FW that includes mixers, coefficients, DAPM graphs, ++ * algorithms, equalisers, DAIs, widgets etc. ++*/ ++ ++#ifndef __LINUX_UAPI_SND_ASOC_H ++#define __LINUX_UAPI_SND_ASOC_H ++ ++#include ++#include ++ ++/* ++ * Maximum number of channels topology kcontrol can represent. ++ */ ++#define SND_SOC_TPLG_MAX_CHAN 8 ++ ++/* ++ * Maximum number of PCM formats capability ++ */ ++#define SND_SOC_TPLG_MAX_FORMATS 16 ++ ++/* ++ * Maximum number of PCM stream configs ++ */ ++#define SND_SOC_TPLG_STREAM_CONFIG_MAX 8 ++ ++/* ++ * Maximum number of physical link's hardware configs ++ */ ++#define SND_SOC_TPLG_HW_CONFIG_MAX 8 ++ ++/* individual kcontrol info types - can be mixed with other types */ ++#define SND_SOC_TPLG_CTL_VOLSW 1 ++#define SND_SOC_TPLG_CTL_VOLSW_SX 2 ++#define SND_SOC_TPLG_CTL_VOLSW_XR_SX 3 ++#define SND_SOC_TPLG_CTL_ENUM 4 ++#define SND_SOC_TPLG_CTL_BYTES 5 ++#define SND_SOC_TPLG_CTL_ENUM_VALUE 6 ++#define SND_SOC_TPLG_CTL_RANGE 7 ++#define SND_SOC_TPLG_CTL_STROBE 8 ++ ++ ++/* individual widget kcontrol info types - can be mixed with other types */ ++#define SND_SOC_TPLG_DAPM_CTL_VOLSW 64 ++#define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE 65 ++#define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT 66 ++#define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE 67 ++#define SND_SOC_TPLG_DAPM_CTL_PIN 68 ++ ++/* DAPM widget types - add new items to the end */ ++#define SND_SOC_TPLG_DAPM_INPUT 0 ++#define SND_SOC_TPLG_DAPM_OUTPUT 1 ++#define SND_SOC_TPLG_DAPM_MUX 2 ++#define SND_SOC_TPLG_DAPM_MIXER 3 ++#define SND_SOC_TPLG_DAPM_PGA 4 ++#define SND_SOC_TPLG_DAPM_OUT_DRV 5 ++#define SND_SOC_TPLG_DAPM_ADC 6 ++#define SND_SOC_TPLG_DAPM_DAC 7 ++#define SND_SOC_TPLG_DAPM_SWITCH 8 ++#define SND_SOC_TPLG_DAPM_PRE 9 ++#define SND_SOC_TPLG_DAPM_POST 10 ++#define SND_SOC_TPLG_DAPM_AIF_IN 11 ++#define SND_SOC_TPLG_DAPM_AIF_OUT 12 ++#define SND_SOC_TPLG_DAPM_DAI_IN 13 ++#define SND_SOC_TPLG_DAPM_DAI_OUT 14 ++#define SND_SOC_TPLG_DAPM_DAI_LINK 15 ++#define SND_SOC_TPLG_DAPM_BUFFER 16 ++#define SND_SOC_TPLG_DAPM_SCHEDULER 17 ++#define SND_SOC_TPLG_DAPM_EFFECT 18 ++#define SND_SOC_TPLG_DAPM_SIGGEN 19 ++#define SND_SOC_TPLG_DAPM_SRC 20 ++#define SND_SOC_TPLG_DAPM_ASRC 21 ++#define SND_SOC_TPLG_DAPM_ENCODER 22 ++#define SND_SOC_TPLG_DAPM_DECODER 23 ++#define SND_SOC_TPLG_DAPM_LAST SND_SOC_TPLG_DAPM_DECODER ++ ++/* Header magic number and string sizes */ ++#define SND_SOC_TPLG_MAGIC 0x41536F43 /* ASoC */ ++ ++/* string sizes */ ++#define SND_SOC_TPLG_NUM_TEXTS 16 ++ ++/* ABI version */ ++#define SND_SOC_TPLG_ABI_VERSION 0x5 /* current version */ ++#define SND_SOC_TPLG_ABI_VERSION_MIN 0x4 /* oldest version supported */ ++ ++/* Max size of TLV data */ ++#define SND_SOC_TPLG_TLV_SIZE 32 ++ ++/* ++ * File and Block header data types. ++ * Add new generic and vendor types to end of list. ++ * Generic types are handled by the core whilst vendors types are passed ++ * to the component drivers for handling. ++ */ ++#define SND_SOC_TPLG_TYPE_MIXER 1 ++#define SND_SOC_TPLG_TYPE_BYTES 2 ++#define SND_SOC_TPLG_TYPE_ENUM 3 ++#define SND_SOC_TPLG_TYPE_DAPM_GRAPH 4 ++#define SND_SOC_TPLG_TYPE_DAPM_WIDGET 5 ++#define SND_SOC_TPLG_TYPE_DAI_LINK 6 ++#define SND_SOC_TPLG_TYPE_PCM 7 ++#define SND_SOC_TPLG_TYPE_MANIFEST 8 ++#define SND_SOC_TPLG_TYPE_CODEC_LINK 9 ++#define SND_SOC_TPLG_TYPE_BACKEND_LINK 10 ++#define SND_SOC_TPLG_TYPE_PDATA 11 ++#define SND_SOC_TPLG_TYPE_DAI 12 ++#define SND_SOC_TPLG_TYPE_MAX SND_SOC_TPLG_TYPE_DAI ++ ++/* vendor block IDs - please add new vendor types to end */ ++#define SND_SOC_TPLG_TYPE_VENDOR_FW 1000 ++#define SND_SOC_TPLG_TYPE_VENDOR_CONFIG 1001 ++#define SND_SOC_TPLG_TYPE_VENDOR_COEFF 1002 ++#define SND_SOC_TPLG_TYPEVENDOR_CODEC 1003 ++ ++#define SND_SOC_TPLG_STREAM_PLAYBACK 0 ++#define SND_SOC_TPLG_STREAM_CAPTURE 1 ++ ++/* vendor tuple types */ ++#define SND_SOC_TPLG_TUPLE_TYPE_UUID 0 ++#define SND_SOC_TPLG_TUPLE_TYPE_STRING 1 ++#define SND_SOC_TPLG_TUPLE_TYPE_BOOL 2 ++#define SND_SOC_TPLG_TUPLE_TYPE_BYTE 3 ++#define SND_SOC_TPLG_TUPLE_TYPE_WORD 4 ++#define SND_SOC_TPLG_TUPLE_TYPE_SHORT 5 ++ ++/* DAI flags */ ++#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES (1 << 0) ++#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) ++#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) ++ ++/* DAI clock gating */ ++#define SND_SOC_TPLG_DAI_CLK_GATE_UNDEFINED 0 ++#define SND_SOC_TPLG_DAI_CLK_GATE_GATED 1 ++#define SND_SOC_TPLG_DAI_CLK_GATE_CONT 2 ++ ++/* DAI mclk_direction */ ++#define SND_SOC_TPLG_MCLK_CO 0 /* for codec, mclk is output */ ++#define SND_SOC_TPLG_MCLK_CI 1 /* for codec, mclk is input */ ++ ++/* DAI physical PCM data formats. ++ * Add new formats to the end of the list. ++ */ ++#define SND_SOC_DAI_FORMAT_I2S 1 /* I2S mode */ ++#define SND_SOC_DAI_FORMAT_RIGHT_J 2 /* Right Justified mode */ ++#define SND_SOC_DAI_FORMAT_LEFT_J 3 /* Left Justified mode */ ++#define SND_SOC_DAI_FORMAT_DSP_A 4 /* L data MSB after FRM LRC */ ++#define SND_SOC_DAI_FORMAT_DSP_B 5 /* L data MSB during FRM LRC */ ++#define SND_SOC_DAI_FORMAT_AC97 6 /* AC97 */ ++#define SND_SOC_DAI_FORMAT_PDM 7 /* Pulse density modulation */ ++ ++/* left and right justified also known as MSB and LSB respectively */ ++#define SND_SOC_DAI_FORMAT_MSB SND_SOC_DAI_FORMAT_LEFT_J ++#define SND_SOC_DAI_FORMAT_LSB SND_SOC_DAI_FORMAT_RIGHT_J ++ ++/* DAI link flags */ ++#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES (1 << 0) ++#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) ++#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) ++#define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP (1 << 3) ++ ++/* DAI topology BCLK parameter ++ * For the backwards capability, by default codec is bclk master ++ */ ++#define SND_SOC_TPLG_BCLK_CM 0 /* codec is bclk master */ ++#define SND_SOC_TPLG_BCLK_CS 1 /* codec is bclk slave */ ++ ++/* DAI topology FSYNC parameter ++ * For the backwards capability, by default codec is fsync master ++ */ ++#define SND_SOC_TPLG_FSYNC_CM 0 /* codec is fsync master */ ++#define SND_SOC_TPLG_FSYNC_CS 1 /* codec is fsync slave */ ++ ++/* ++ * Block Header. ++ * This header precedes all object and object arrays below. ++ */ ++struct snd_soc_tplg_hdr { ++ __le32 magic; /* magic number */ ++ __le32 abi; /* ABI version */ ++ __le32 version; /* optional vendor specific version details */ ++ __le32 type; /* SND_SOC_TPLG_TYPE_ */ ++ __le32 size; /* size of this structure */ ++ __le32 vendor_type; /* optional vendor specific type info */ ++ __le32 payload_size; /* data bytes, excluding this header */ ++ __le32 index; /* identifier for block */ ++ __le32 count; /* number of elements in block */ ++} __attribute__((packed)); ++ ++/* vendor tuple for uuid */ ++struct snd_soc_tplg_vendor_uuid_elem { ++ __le32 token; ++ char uuid[16]; ++} __attribute__((packed)); ++ ++/* vendor tuple for a bool/byte/short/word value */ ++struct snd_soc_tplg_vendor_value_elem { ++ __le32 token; ++ __le32 value; ++} __attribute__((packed)); ++ ++/* vendor tuple for string */ ++struct snd_soc_tplg_vendor_string_elem { ++ __le32 token; ++ char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++} __attribute__((packed)); ++ ++struct snd_soc_tplg_vendor_array { ++ __le32 size; /* size in bytes of the array, including all elements */ ++ __le32 type; /* SND_SOC_TPLG_TUPLE_TYPE_ */ ++ __le32 num_elems; /* number of elements in array */ ++ union { ++ struct snd_soc_tplg_vendor_uuid_elem uuid[0]; ++ struct snd_soc_tplg_vendor_value_elem value[0]; ++ struct snd_soc_tplg_vendor_string_elem string[0]; ++ }; ++} __attribute__((packed)); ++ ++/* ++ * Private data. ++ * All topology objects may have private data that can be used by the driver or ++ * firmware. Core will ignore this data. ++ */ ++struct snd_soc_tplg_private { ++ __le32 size; /* in bytes of private data */ ++ union { ++ char data[0]; ++ struct snd_soc_tplg_vendor_array array[0]; ++ }; ++} __attribute__((packed)); ++ ++/* ++ * Kcontrol TLV data. ++ */ ++struct snd_soc_tplg_tlv_dbscale { ++ __le32 min; ++ __le32 step; ++ __le32 mute; ++} __attribute__((packed)); ++ ++struct snd_soc_tplg_ctl_tlv { ++ __le32 size; /* in bytes of this structure */ ++ __le32 type; /* SNDRV_CTL_TLVT_*, type of TLV */ ++ union { ++ __le32 data[SND_SOC_TPLG_TLV_SIZE]; ++ struct snd_soc_tplg_tlv_dbscale scale; ++ }; ++} __attribute__((packed)); ++ ++/* ++ * Kcontrol channel data ++ */ ++struct snd_soc_tplg_channel { ++ __le32 size; /* in bytes of this structure */ ++ __le32 reg; ++ __le32 shift; ++ __le32 id; /* ID maps to Left, Right, LFE etc */ ++} __attribute__((packed)); ++ ++/* ++ * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops ++ * Kcontrol ops need get/put/info. ++ * Bytes ext ops need get/put. ++ */ ++struct snd_soc_tplg_io_ops { ++ __le32 get; ++ __le32 put; ++ __le32 info; ++} __attribute__((packed)); ++ ++/* ++ * kcontrol header ++ */ ++struct snd_soc_tplg_ctl_hdr { ++ __le32 size; /* in bytes of this structure */ ++ __le32 type; ++ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ __le32 access; ++ struct snd_soc_tplg_io_ops ops; ++ struct snd_soc_tplg_ctl_tlv tlv; ++} __attribute__((packed)); ++ ++/* ++ * Stream Capabilities ++ */ ++struct snd_soc_tplg_stream_caps { ++ __le32 size; /* in bytes of this structure */ ++ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ ++ __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ ++ __le32 rate_min; /* min rate */ ++ __le32 rate_max; /* max rate */ ++ __le32 channels_min; /* min channels */ ++ __le32 channels_max; /* max channels */ ++ __le32 periods_min; /* min number of periods */ ++ __le32 periods_max; /* max number of periods */ ++ __le32 period_size_min; /* min period size bytes */ ++ __le32 period_size_max; /* max period size bytes */ ++ __le32 buffer_size_min; /* min buffer size bytes */ ++ __le32 buffer_size_max; /* max buffer size bytes */ ++ __le32 sig_bits; /* number of bits of content */ ++} __attribute__((packed)); ++ ++/* ++ * FE or BE Stream configuration supported by SW/FW ++ */ ++struct snd_soc_tplg_stream { ++ __le32 size; /* in bytes of this structure */ ++ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* Name of the stream */ ++ __le64 format; /* SNDRV_PCM_FMTBIT_* */ ++ __le32 rate; /* SNDRV_PCM_RATE_* */ ++ __le32 period_bytes; /* size of period in bytes */ ++ __le32 buffer_bytes; /* size of buffer in bytes */ ++ __le32 channels; /* channels */ ++} __attribute__((packed)); ++ ++ ++/* ++ * Describes a physical link's runtime supported hardware config, ++ * i.e. hardware audio formats. ++ */ ++struct snd_soc_tplg_hw_config { ++ __le32 size; /* in bytes of this structure */ ++ __le32 id; /* unique ID - - used to match */ ++ __le32 fmt; /* SND_SOC_DAI_FORMAT_ format value */ ++ __u8 clock_gated; /* SND_SOC_TPLG_DAI_CLK_GATE_ value */ ++ __u8 invert_bclk; /* 1 for inverted BCLK, 0 for normal */ ++ __u8 invert_fsync; /* 1 for inverted frame clock, 0 for normal */ ++ __u8 bclk_master; /* SND_SOC_TPLG_BCLK_ value */ ++ __u8 fsync_master; /* SND_SOC_TPLG_FSYNC_ value */ ++ __u8 mclk_direction; /* SND_SOC_TPLG_MCLK_ value */ ++ __le16 reserved; /* for 32bit alignment */ ++ __le32 mclk_rate; /* MCLK or SYSCLK freqency in Hz */ ++ __le32 bclk_rate; /* BCLK freqency in Hz */ ++ __le32 fsync_rate; /* frame clock in Hz */ ++ __le32 tdm_slots; /* number of TDM slots in use */ ++ __le32 tdm_slot_width; /* width in bits for each slot */ ++ __le32 tx_slots; /* bit mask for active Tx slots */ ++ __le32 rx_slots; /* bit mask for active Rx slots */ ++ __le32 tx_channels; /* number of Tx channels */ ++ __le32 tx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */ ++ __le32 rx_channels; /* number of Rx channels */ ++ __le32 rx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */ ++} __attribute__((packed)); ++ ++/* ++ * Manifest. List totals for each payload type. Not used in parsing, but will ++ * be passed to the component driver before any other objects in order for any ++ * global component resource allocations. ++ * ++ * File block representation for manifest :- ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_manifest | 1 | ++ * +-----------------------------------+----+ ++ */ ++struct snd_soc_tplg_manifest { ++ __le32 size; /* in bytes of this structure */ ++ __le32 control_elems; /* number of control elements */ ++ __le32 widget_elems; /* number of widget elements */ ++ __le32 graph_elems; /* number of graph elements */ ++ __le32 pcm_elems; /* number of PCM elements */ ++ __le32 dai_link_elems; /* number of DAI link elements */ ++ __le32 dai_elems; /* number of physical DAI elements */ ++ __le32 reserved[20]; /* reserved for new ABI element types */ ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++/* ++ * Mixer kcontrol. ++ * ++ * File block representation for mixer kcontrol :- ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_mixer_control | N | ++ * +-----------------------------------+----+ ++ */ ++struct snd_soc_tplg_mixer_control { ++ struct snd_soc_tplg_ctl_hdr hdr; ++ __le32 size; /* in bytes of this structure */ ++ __le32 min; ++ __le32 max; ++ __le32 platform_max; ++ __le32 invert; ++ __le32 num_channels; ++ struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++/* ++ * Enumerated kcontrol ++ * ++ * File block representation for enum kcontrol :- ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_enum_control | N | ++ * +-----------------------------------+----+ ++ */ ++struct snd_soc_tplg_enum_control { ++ struct snd_soc_tplg_ctl_hdr hdr; ++ __le32 size; /* in bytes of this structure */ ++ __le32 num_channels; ++ struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; ++ __le32 items; ++ __le32 mask; ++ __le32 count; ++ char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ __le32 values[SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4]; ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++/* ++ * Bytes kcontrol ++ * ++ * File block representation for bytes kcontrol :- ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+----+ ++ * | struct snd_soc_tplg_bytes_control | N | ++ * +-----------------------------------+----+ ++ */ ++struct snd_soc_tplg_bytes_control { ++ struct snd_soc_tplg_ctl_hdr hdr; ++ __le32 size; /* in bytes of this structure */ ++ __le32 max; ++ __le32 mask; ++ __le32 base; ++ __le32 num_regs; ++ struct snd_soc_tplg_io_ops ext_ops; ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++/* ++ * DAPM Graph Element ++ * ++ * File block representation for DAPM graph elements :- ++ * +-------------------------------------+----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-------------------------------------+----+ ++ * | struct snd_soc_tplg_dapm_graph_elem | N | ++ * +-------------------------------------+----+ ++ */ ++struct snd_soc_tplg_dapm_graph_elem { ++ char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++} __attribute__((packed)); ++ ++/* ++ * DAPM Widget. ++ * ++ * File block representation for DAPM widget :- ++ * +-------------------------------------+-----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-------------------------------------+-----+ ++ * | struct snd_soc_tplg_dapm_widget | N | ++ * +-------------------------------------+-----+ ++ * | struct snd_soc_tplg_enum_control | 0|1 | ++ * | struct snd_soc_tplg_mixer_control | 0|N | ++ * +-------------------------------------+-----+ ++ * ++ * Optional enum or mixer control can be appended to the end of each widget ++ * in the block. ++ */ ++struct snd_soc_tplg_dapm_widget { ++ __le32 size; /* in bytes of this structure */ ++ __le32 id; /* SND_SOC_DAPM_CTL */ ++ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ ++ __le32 reg; /* negative reg = no direct dapm */ ++ __le32 shift; /* bits to shift */ ++ __le32 mask; /* non-shifted mask */ ++ __le32 subseq; /* sort within widget type */ ++ __le32 invert; /* invert the power bit */ ++ __le32 ignore_suspend; /* kept enabled over suspend */ ++ __le16 event_flags; ++ __le16 event_type; ++ __le32 num_kcontrols; ++ struct snd_soc_tplg_private priv; ++ /* ++ * kcontrols that relate to this widget ++ * follow here after widget private data ++ */ ++} __attribute__((packed)); ++ ++ ++/* ++ * Describes SW/FW specific features of PCM (FE DAI & DAI link). ++ * ++ * File block representation for PCM :- ++ * +-----------------------------------+-----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+-----+ ++ * | struct snd_soc_tplg_pcm | N | ++ * +-----------------------------------+-----+ ++ */ ++struct snd_soc_tplg_pcm { ++ __le32 size; /* in bytes of this structure */ ++ char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ __le32 pcm_id; /* unique ID - used to match with DAI link */ ++ __le32 dai_id; /* unique ID - used to match */ ++ __le32 playback; /* supports playback mode */ ++ __le32 capture; /* supports capture mode */ ++ __le32 compress; /* 1 = compressed; 0 = PCM */ ++ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ ++ __le32 num_streams; /* number of streams */ ++ struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ ++ __le32 flag_mask; /* bitmask of flags to configure */ ++ __le32 flags; /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */ ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++ ++/* ++ * Describes the physical link runtime supported configs or params ++ * ++ * File block representation for physical link config :- ++ * +-----------------------------------+-----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+-----+ ++ * | struct snd_soc_tplg_link_config | N | ++ * +-----------------------------------+-----+ ++ */ ++struct snd_soc_tplg_link_config { ++ __le32 size; /* in bytes of this structure */ ++ __le32 id; /* unique ID - used to match */ ++ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ ++ char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* stream name - used to match */ ++ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ ++ __le32 num_streams; /* number of streams */ ++ struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; /* hw configs */ ++ __le32 num_hw_configs; /* number of hw configs */ ++ __le32 default_hw_config_id; /* default hw config ID for init */ ++ __le32 flag_mask; /* bitmask of flags to configure */ ++ __le32 flags; /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */ ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++/* ++ * Describes SW/FW specific features of physical DAI. ++ * It can be used to configure backend DAIs for DPCM. ++ * ++ * File block representation for physical DAI :- ++ * +-----------------------------------+-----+ ++ * | struct snd_soc_tplg_hdr | 1 | ++ * +-----------------------------------+-----+ ++ * | struct snd_soc_tplg_dai | N | ++ * +-----------------------------------+-----+ ++ */ ++struct snd_soc_tplg_dai { ++ __le32 size; /* in bytes of this structure */ ++ char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */ ++ __le32 dai_id; /* unique ID - used to match */ ++ __le32 playback; /* supports playback mode */ ++ __le32 capture; /* supports capture mode */ ++ struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */ ++ __le32 flag_mask; /* bitmask of flags to configure */ ++ __le32 flags; /* SND_SOC_TPLG_DAI_FLGBIT_* */ ++ struct snd_soc_tplg_private priv; ++} __attribute__((packed)); ++ ++/* ++ * Old version of ABI structs, supported for backward compatibility. ++ */ ++ ++/* Manifest v4 */ ++struct snd_soc_tplg_manifest_v4 { ++ __le32 size; /* in bytes of this structure */ ++ __le32 control_elems; /* number of control elements */ ++ __le32 widget_elems; /* number of widget elements */ ++ __le32 graph_elems; /* number of graph elements */ ++ __le32 pcm_elems; /* number of PCM elements */ ++ __le32 dai_link_elems; /* number of DAI link elements */ ++ struct snd_soc_tplg_private priv; ++} __packed; ++ ++/* Stream Capabilities v4 */ ++struct snd_soc_tplg_stream_caps_v4 { ++ __le32 size; /* in bytes of this structure */ ++ char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ __le64 formats; /* supported formats SNDRV_PCM_FMTBIT_* */ ++ __le32 rates; /* supported rates SNDRV_PCM_RATE_* */ ++ __le32 rate_min; /* min rate */ ++ __le32 rate_max; /* max rate */ ++ __le32 channels_min; /* min channels */ ++ __le32 channels_max; /* max channels */ ++ __le32 periods_min; /* min number of periods */ ++ __le32 periods_max; /* max number of periods */ ++ __le32 period_size_min; /* min period size bytes */ ++ __le32 period_size_max; /* max period size bytes */ ++ __le32 buffer_size_min; /* min buffer size bytes */ ++ __le32 buffer_size_max; /* max buffer size bytes */ ++} __packed; ++ ++/* PCM v4 */ ++struct snd_soc_tplg_pcm_v4 { ++ __le32 size; /* in bytes of this structure */ ++ char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; ++ __le32 pcm_id; /* unique ID - used to match with DAI link */ ++ __le32 dai_id; /* unique ID - used to match */ ++ __le32 playback; /* supports playback mode */ ++ __le32 capture; /* supports capture mode */ ++ __le32 compress; /* 1 = compressed; 0 = PCM */ ++ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */ ++ __le32 num_streams; /* number of streams */ ++ struct snd_soc_tplg_stream_caps_v4 caps[2]; /* playback and capture for DAI */ ++} __packed; ++ ++/* Physical link config v4 */ ++struct snd_soc_tplg_link_config_v4 { ++ __le32 size; /* in bytes of this structure */ ++ __le32 id; /* unique ID - used to match */ ++ struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */ ++ __le32 num_streams; /* number of streams */ ++} __packed; ++ ++#endif +diff --git a/include/sound/uapi/asound.h b/include/sound/uapi/asound.h +new file mode 100644 +index 000000000000..df1153cea0b7 +--- /dev/null ++++ b/include/sound/uapi/asound.h +@@ -0,0 +1,1038 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++/* ++ * Advanced Linux Sound Architecture - ALSA - Driver ++ * Copyright (c) 1994-2003 by Jaroslav Kysela , ++ * Abramo Bagnara ++ * ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ */ ++ ++#ifndef _UAPI__SOUND_ASOUND_H ++#define _UAPI__SOUND_ASOUND_H ++ ++#if defined(__KERNEL__) || defined(__linux__) ++#include ++#else ++#include ++#endif ++ ++#ifndef __KERNEL__ ++#include ++#include ++#endif ++ ++/* ++ * protocol version ++ */ ++ ++#define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor)) ++#define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff) ++#define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff) ++#define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff) ++#define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \ ++ (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \ ++ (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \ ++ SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion))) ++ ++/**************************************************************************** ++ * * ++ * Digital audio interface * ++ * * ++ ****************************************************************************/ ++ ++struct snd_aes_iec958 { ++ unsigned char status[24]; /* AES/IEC958 channel status bits */ ++ unsigned char subcode[147]; /* AES/IEC958 subcode bits */ ++ unsigned char pad; /* nothing */ ++ unsigned char dig_subframe[4]; /* AES/IEC958 subframe bits */ ++}; ++ ++/**************************************************************************** ++ * * ++ * CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort * ++ * * ++ ****************************************************************************/ ++ ++struct snd_cea_861_aud_if { ++ unsigned char db1_ct_cc; /* coding type and channel count */ ++ unsigned char db2_sf_ss; /* sample frequency and size */ ++ unsigned char db3; /* not used, all zeros */ ++ unsigned char db4_ca; /* channel allocation code */ ++ unsigned char db5_dminh_lsv; /* downmix inhibit & level-shit values */ ++}; ++ ++/**************************************************************************** ++ * * ++ * Section for driver hardware dependent interface - /dev/snd/hw? * ++ * * ++ ****************************************************************************/ ++ ++#define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) ++ ++enum { ++ SNDRV_HWDEP_IFACE_OPL2 = 0, ++ SNDRV_HWDEP_IFACE_OPL3, ++ SNDRV_HWDEP_IFACE_OPL4, ++ SNDRV_HWDEP_IFACE_SB16CSP, /* Creative Signal Processor */ ++ SNDRV_HWDEP_IFACE_EMU10K1, /* FX8010 processor in EMU10K1 chip */ ++ SNDRV_HWDEP_IFACE_YSS225, /* Yamaha FX processor */ ++ SNDRV_HWDEP_IFACE_ICS2115, /* Wavetable synth */ ++ SNDRV_HWDEP_IFACE_SSCAPE, /* Ensoniq SoundScape ISA card (MC68EC000) */ ++ SNDRV_HWDEP_IFACE_VX, /* Digigram VX cards */ ++ SNDRV_HWDEP_IFACE_MIXART, /* Digigram miXart cards */ ++ SNDRV_HWDEP_IFACE_USX2Y, /* Tascam US122, US224 & US428 usb */ ++ SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */ ++ SNDRV_HWDEP_IFACE_BLUETOOTH, /* Bluetooth audio */ ++ SNDRV_HWDEP_IFACE_USX2Y_PCM, /* Tascam US122, US224 & US428 rawusb pcm */ ++ SNDRV_HWDEP_IFACE_PCXHR, /* Digigram PCXHR */ ++ SNDRV_HWDEP_IFACE_SB_RC, /* SB Extigy/Audigy2NX remote control */ ++ SNDRV_HWDEP_IFACE_HDA, /* HD-audio */ ++ SNDRV_HWDEP_IFACE_USB_STREAM, /* direct access to usb stream */ ++ SNDRV_HWDEP_IFACE_FW_DICE, /* TC DICE FireWire device */ ++ SNDRV_HWDEP_IFACE_FW_FIREWORKS, /* Echo Audio Fireworks based device */ ++ SNDRV_HWDEP_IFACE_FW_BEBOB, /* BridgeCo BeBoB based device */ ++ SNDRV_HWDEP_IFACE_FW_OXFW, /* Oxford OXFW970/971 based device */ ++ SNDRV_HWDEP_IFACE_FW_DIGI00X, /* Digidesign Digi 002/003 family */ ++ SNDRV_HWDEP_IFACE_FW_TASCAM, /* TASCAM FireWire series */ ++ SNDRV_HWDEP_IFACE_LINE6, /* Line6 USB processors */ ++ SNDRV_HWDEP_IFACE_FW_MOTU, /* MOTU FireWire series */ ++ SNDRV_HWDEP_IFACE_FW_FIREFACE, /* RME Fireface series */ ++ ++ /* Don't forget to change the following: */ ++ SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_FIREFACE ++}; ++ ++struct snd_hwdep_info { ++ unsigned int device; /* WR: device number */ ++ int card; /* R: card number */ ++ unsigned char id[64]; /* ID (user selectable) */ ++ unsigned char name[80]; /* hwdep name */ ++ int iface; /* hwdep interface */ ++ unsigned char reserved[64]; /* reserved for future */ ++}; ++ ++/* generic DSP loader */ ++struct snd_hwdep_dsp_status { ++ unsigned int version; /* R: driver-specific version */ ++ unsigned char id[32]; /* R: driver-specific ID string */ ++ unsigned int num_dsps; /* R: number of DSP images to transfer */ ++ unsigned int dsp_loaded; /* R: bit flags indicating the loaded DSPs */ ++ unsigned int chip_ready; /* R: 1 = initialization finished */ ++ unsigned char reserved[16]; /* reserved for future use */ ++}; ++ ++struct snd_hwdep_dsp_image { ++ unsigned int index; /* W: DSP index */ ++ unsigned char name[64]; /* W: ID (e.g. file name) */ ++ unsigned char __user *image; /* W: binary image */ ++ size_t length; /* W: size of image in bytes */ ++ unsigned long driver_data; /* W: driver-specific data */ ++}; ++ ++#define SNDRV_HWDEP_IOCTL_PVERSION _IOR ('H', 0x00, int) ++#define SNDRV_HWDEP_IOCTL_INFO _IOR ('H', 0x01, struct snd_hwdep_info) ++#define SNDRV_HWDEP_IOCTL_DSP_STATUS _IOR('H', 0x02, struct snd_hwdep_dsp_status) ++#define SNDRV_HWDEP_IOCTL_DSP_LOAD _IOW('H', 0x03, struct snd_hwdep_dsp_image) ++ ++/***************************************************************************** ++ * * ++ * Digital Audio (PCM) interface - /dev/snd/pcm?? * ++ * * ++ *****************************************************************************/ ++ ++#define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 14) ++ ++typedef unsigned long snd_pcm_uframes_t; ++typedef signed long snd_pcm_sframes_t; ++ ++enum { ++ SNDRV_PCM_CLASS_GENERIC = 0, /* standard mono or stereo device */ ++ SNDRV_PCM_CLASS_MULTI, /* multichannel device */ ++ SNDRV_PCM_CLASS_MODEM, /* software modem class */ ++ SNDRV_PCM_CLASS_DIGITIZER, /* digitizer class */ ++ /* Don't forget to change the following: */ ++ SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER, ++}; ++ ++enum { ++ SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */ ++ SNDRV_PCM_SUBCLASS_MULTI_MIX, /* multichannel subdevices are mixed together */ ++ /* Don't forget to change the following: */ ++ SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX, ++}; ++ ++enum { ++ SNDRV_PCM_STREAM_PLAYBACK = 0, ++ SNDRV_PCM_STREAM_CAPTURE, ++ SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, ++}; ++ ++typedef int __bitwise snd_pcm_access_t; ++#define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED ((__force snd_pcm_access_t) 0) /* interleaved mmap */ ++#define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED ((__force snd_pcm_access_t) 1) /* noninterleaved mmap */ ++#define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((__force snd_pcm_access_t) 2) /* complex mmap */ ++#define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((__force snd_pcm_access_t) 3) /* readi/writei */ ++#define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ((__force snd_pcm_access_t) 4) /* readn/writen */ ++#define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ++ ++typedef int __bitwise snd_pcm_format_t; ++#define SNDRV_PCM_FORMAT_S8 ((__force snd_pcm_format_t) 0) ++#define SNDRV_PCM_FORMAT_U8 ((__force snd_pcm_format_t) 1) ++#define SNDRV_PCM_FORMAT_S16_LE ((__force snd_pcm_format_t) 2) ++#define SNDRV_PCM_FORMAT_S16_BE ((__force snd_pcm_format_t) 3) ++#define SNDRV_PCM_FORMAT_U16_LE ((__force snd_pcm_format_t) 4) ++#define SNDRV_PCM_FORMAT_U16_BE ((__force snd_pcm_format_t) 5) ++#define SNDRV_PCM_FORMAT_S24_LE ((__force snd_pcm_format_t) 6) /* low three bytes */ ++#define SNDRV_PCM_FORMAT_S24_BE ((__force snd_pcm_format_t) 7) /* low three bytes */ ++#define SNDRV_PCM_FORMAT_U24_LE ((__force snd_pcm_format_t) 8) /* low three bytes */ ++#define SNDRV_PCM_FORMAT_U24_BE ((__force snd_pcm_format_t) 9) /* low three bytes */ ++#define SNDRV_PCM_FORMAT_S32_LE ((__force snd_pcm_format_t) 10) ++#define SNDRV_PCM_FORMAT_S32_BE ((__force snd_pcm_format_t) 11) ++#define SNDRV_PCM_FORMAT_U32_LE ((__force snd_pcm_format_t) 12) ++#define SNDRV_PCM_FORMAT_U32_BE ((__force snd_pcm_format_t) 13) ++#define SNDRV_PCM_FORMAT_FLOAT_LE ((__force snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ ++#define SNDRV_PCM_FORMAT_FLOAT_BE ((__force snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */ ++#define SNDRV_PCM_FORMAT_FLOAT64_LE ((__force snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ ++#define SNDRV_PCM_FORMAT_FLOAT64_BE ((__force snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */ ++#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */ ++#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */ ++#define SNDRV_PCM_FORMAT_MU_LAW ((__force snd_pcm_format_t) 20) ++#define SNDRV_PCM_FORMAT_A_LAW ((__force snd_pcm_format_t) 21) ++#define SNDRV_PCM_FORMAT_IMA_ADPCM ((__force snd_pcm_format_t) 22) ++#define SNDRV_PCM_FORMAT_MPEG ((__force snd_pcm_format_t) 23) ++#define SNDRV_PCM_FORMAT_GSM ((__force snd_pcm_format_t) 24) ++#define SNDRV_PCM_FORMAT_S20_LE ((__force snd_pcm_format_t) 25) /* in four bytes, LSB justified */ ++#define SNDRV_PCM_FORMAT_S20_BE ((__force snd_pcm_format_t) 26) /* in four bytes, LSB justified */ ++#define SNDRV_PCM_FORMAT_U20_LE ((__force snd_pcm_format_t) 27) /* in four bytes, LSB justified */ ++#define SNDRV_PCM_FORMAT_U20_BE ((__force snd_pcm_format_t) 28) /* in four bytes, LSB justified */ ++/* gap in the numbering for a future standard linear format */ ++#define SNDRV_PCM_FORMAT_SPECIAL ((__force snd_pcm_format_t) 31) ++#define SNDRV_PCM_FORMAT_S24_3LE ((__force snd_pcm_format_t) 32) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_S24_3BE ((__force snd_pcm_format_t) 33) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_U24_3LE ((__force snd_pcm_format_t) 34) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_U24_3BE ((__force snd_pcm_format_t) 35) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_S20_3LE ((__force snd_pcm_format_t) 36) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_S20_3BE ((__force snd_pcm_format_t) 37) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_U20_3LE ((__force snd_pcm_format_t) 38) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_U20_3BE ((__force snd_pcm_format_t) 39) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_S18_3LE ((__force snd_pcm_format_t) 40) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_S18_3BE ((__force snd_pcm_format_t) 41) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_U18_3LE ((__force snd_pcm_format_t) 42) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_U18_3BE ((__force snd_pcm_format_t) 43) /* in three bytes */ ++#define SNDRV_PCM_FORMAT_G723_24 ((__force snd_pcm_format_t) 44) /* 8 samples in 3 bytes */ ++#define SNDRV_PCM_FORMAT_G723_24_1B ((__force snd_pcm_format_t) 45) /* 1 sample in 1 byte */ ++#define SNDRV_PCM_FORMAT_G723_40 ((__force snd_pcm_format_t) 46) /* 8 Samples in 5 bytes */ ++#define SNDRV_PCM_FORMAT_G723_40_1B ((__force snd_pcm_format_t) 47) /* 1 sample in 1 byte */ ++#define SNDRV_PCM_FORMAT_DSD_U8 ((__force snd_pcm_format_t) 48) /* DSD, 1-byte samples DSD (x8) */ ++#define SNDRV_PCM_FORMAT_DSD_U16_LE ((__force snd_pcm_format_t) 49) /* DSD, 2-byte samples DSD (x16), little endian */ ++#define SNDRV_PCM_FORMAT_DSD_U32_LE ((__force snd_pcm_format_t) 50) /* DSD, 4-byte samples DSD (x32), little endian */ ++#define SNDRV_PCM_FORMAT_DSD_U16_BE ((__force snd_pcm_format_t) 51) /* DSD, 2-byte samples DSD (x16), big endian */ ++#define SNDRV_PCM_FORMAT_DSD_U32_BE ((__force snd_pcm_format_t) 52) /* DSD, 4-byte samples DSD (x32), big endian */ ++#define SNDRV_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_DSD_U32_BE ++#define SNDRV_PCM_FORMAT_FIRST SNDRV_PCM_FORMAT_S8 ++ ++#ifdef SNDRV_LITTLE_ENDIAN ++#define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_LE ++#define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_LE ++#define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_LE ++#define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_LE ++#define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_LE ++#define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_LE ++#define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_LE ++#define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_LE ++#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ++#define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_LE ++#define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_LE ++#endif ++#ifdef SNDRV_BIG_ENDIAN ++#define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_BE ++#define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_BE ++#define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_BE ++#define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_BE ++#define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_BE ++#define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_BE ++#define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_BE ++#define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_BE ++#define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ++#define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_BE ++#define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_BE ++#endif ++ ++typedef int __bitwise snd_pcm_subformat_t; ++#define SNDRV_PCM_SUBFORMAT_STD ((__force snd_pcm_subformat_t) 0) ++#define SNDRV_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_STD ++ ++#define SNDRV_PCM_INFO_MMAP 0x00000001 /* hardware supports mmap */ ++#define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 /* period data are valid during transfer */ ++#define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ ++#define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ ++#define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ ++#define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ ++#define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ ++#define SNDRV_PCM_INFO_BLOCK_TRANSFER 0x00010000 /* hardware transfer block of samples */ ++#define SNDRV_PCM_INFO_OVERRANGE 0x00020000 /* hardware supports ADC (capture) overrange detection */ ++#define SNDRV_PCM_INFO_RESUME 0x00040000 /* hardware supports stream resume after suspend */ ++#define SNDRV_PCM_INFO_PAUSE 0x00080000 /* pause ioctl is supported */ ++#define SNDRV_PCM_INFO_HALF_DUPLEX 0x00100000 /* only half duplex */ ++#define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 /* playback and capture stream are somewhat correlated */ ++#define SNDRV_PCM_INFO_SYNC_START 0x00400000 /* pcm support some kind of sync go */ ++#define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP 0x00800000 /* period wakeup can be disabled */ ++#define SNDRV_PCM_INFO_HAS_WALL_CLOCK 0x01000000 /* (Deprecated)has audio wall clock for audio/system time sync */ ++#define SNDRV_PCM_INFO_HAS_LINK_ATIME 0x01000000 /* report hardware link audio time, reset on startup */ ++#define SNDRV_PCM_INFO_HAS_LINK_ABSOLUTE_ATIME 0x02000000 /* report absolute hardware link audio time, not reset on startup */ ++#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME 0x04000000 /* report estimated link audio time */ ++#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000 /* report synchronized audio/system time */ ++ ++#define SNDRV_PCM_INFO_DRAIN_TRIGGER 0x40000000 /* internal kernel flag - trigger in drain */ ++#define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 /* internal kernel flag - FIFO size is in frames */ ++ ++ ++ ++typedef int __bitwise snd_pcm_state_t; ++#define SNDRV_PCM_STATE_OPEN ((__force snd_pcm_state_t) 0) /* stream is open */ ++#define SNDRV_PCM_STATE_SETUP ((__force snd_pcm_state_t) 1) /* stream has a setup */ ++#define SNDRV_PCM_STATE_PREPARED ((__force snd_pcm_state_t) 2) /* stream is ready to start */ ++#define SNDRV_PCM_STATE_RUNNING ((__force snd_pcm_state_t) 3) /* stream is running */ ++#define SNDRV_PCM_STATE_XRUN ((__force snd_pcm_state_t) 4) /* stream reached an xrun */ ++#define SNDRV_PCM_STATE_DRAINING ((__force snd_pcm_state_t) 5) /* stream is draining */ ++#define SNDRV_PCM_STATE_PAUSED ((__force snd_pcm_state_t) 6) /* stream is paused */ ++#define SNDRV_PCM_STATE_SUSPENDED ((__force snd_pcm_state_t) 7) /* hardware is suspended */ ++#define SNDRV_PCM_STATE_DISCONNECTED ((__force snd_pcm_state_t) 8) /* hardware is disconnected */ ++#define SNDRV_PCM_STATE_LAST SNDRV_PCM_STATE_DISCONNECTED ++ ++enum { ++ SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000, ++ SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000, ++ SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000, ++}; ++ ++union snd_pcm_sync_id { ++ unsigned char id[16]; ++ unsigned short id16[8]; ++ unsigned int id32[4]; ++}; ++ ++struct snd_pcm_info { ++ unsigned int device; /* RO/WR (control): device number */ ++ unsigned int subdevice; /* RO/WR (control): subdevice number */ ++ int stream; /* RO/WR (control): stream direction */ ++ int card; /* R: card number */ ++ unsigned char id[64]; /* ID (user selectable) */ ++ unsigned char name[80]; /* name of this device */ ++ unsigned char subname[32]; /* subdevice name */ ++ int dev_class; /* SNDRV_PCM_CLASS_* */ ++ int dev_subclass; /* SNDRV_PCM_SUBCLASS_* */ ++ unsigned int subdevices_count; ++ unsigned int subdevices_avail; ++ union snd_pcm_sync_id sync; /* hardware synchronization ID */ ++ unsigned char reserved[64]; /* reserved for future... */ ++}; ++ ++typedef int snd_pcm_hw_param_t; ++#define SNDRV_PCM_HW_PARAM_ACCESS 0 /* Access type */ ++#define SNDRV_PCM_HW_PARAM_FORMAT 1 /* Format */ ++#define SNDRV_PCM_HW_PARAM_SUBFORMAT 2 /* Subformat */ ++#define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS ++#define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT ++ ++#define SNDRV_PCM_HW_PARAM_SAMPLE_BITS 8 /* Bits per sample */ ++#define SNDRV_PCM_HW_PARAM_FRAME_BITS 9 /* Bits per frame */ ++#define SNDRV_PCM_HW_PARAM_CHANNELS 10 /* Channels */ ++#define SNDRV_PCM_HW_PARAM_RATE 11 /* Approx rate */ ++#define SNDRV_PCM_HW_PARAM_PERIOD_TIME 12 /* Approx distance between ++ * interrupts in us ++ */ ++#define SNDRV_PCM_HW_PARAM_PERIOD_SIZE 13 /* Approx frames between ++ * interrupts ++ */ ++#define SNDRV_PCM_HW_PARAM_PERIOD_BYTES 14 /* Approx bytes between ++ * interrupts ++ */ ++#define SNDRV_PCM_HW_PARAM_PERIODS 15 /* Approx interrupts per ++ * buffer ++ */ ++#define SNDRV_PCM_HW_PARAM_BUFFER_TIME 16 /* Approx duration of buffer ++ * in us ++ */ ++#define SNDRV_PCM_HW_PARAM_BUFFER_SIZE 17 /* Size of buffer in frames */ ++#define SNDRV_PCM_HW_PARAM_BUFFER_BYTES 18 /* Size of buffer in bytes */ ++#define SNDRV_PCM_HW_PARAM_TICK_TIME 19 /* Approx tick duration in us */ ++#define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_SAMPLE_BITS ++#define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME ++ ++#define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ ++#define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ ++#define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++ ++struct snd_interval { ++ unsigned int min, max; ++ unsigned int openmin:1, ++ openmax:1, ++ integer:1, ++ empty:1; ++}; ++ ++#define SNDRV_MASK_MAX 256 ++ ++struct snd_mask { ++ __u32 bits[(SNDRV_MASK_MAX+31)/32]; ++}; ++ ++struct snd_pcm_hw_params { ++ unsigned int flags; ++ struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - ++ SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; ++ struct snd_mask mres[5]; /* reserved masks */ ++ struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - ++ SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; ++ struct snd_interval ires[9]; /* reserved intervals */ ++ unsigned int rmask; /* W: requested masks */ ++ unsigned int cmask; /* R: changed masks */ ++ unsigned int info; /* R: Info flags for returned setup */ ++ unsigned int msbits; /* R: used most significant bits */ ++ unsigned int rate_num; /* R: rate numerator */ ++ unsigned int rate_den; /* R: rate denominator */ ++ snd_pcm_uframes_t fifo_size; /* R: chip FIFO size in frames */ ++ unsigned char reserved[64]; /* reserved for future */ ++}; ++ ++enum { ++ SNDRV_PCM_TSTAMP_NONE = 0, ++ SNDRV_PCM_TSTAMP_ENABLE, ++ SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE, ++}; ++ ++struct snd_pcm_sw_params { ++ int tstamp_mode; /* timestamp mode */ ++ unsigned int period_step; ++ unsigned int sleep_min; /* min ticks to sleep */ ++ snd_pcm_uframes_t avail_min; /* min avail frames for wakeup */ ++ snd_pcm_uframes_t xfer_align; /* obsolete: xfer size need to be a multiple */ ++ snd_pcm_uframes_t start_threshold; /* min hw_avail frames for automatic start */ ++ snd_pcm_uframes_t stop_threshold; /* min avail frames for automatic stop */ ++ snd_pcm_uframes_t silence_threshold; /* min distance from noise for silence filling */ ++ snd_pcm_uframes_t silence_size; /* silence block size */ ++ snd_pcm_uframes_t boundary; /* pointers wrap point */ ++ unsigned int proto; /* protocol version */ ++ unsigned int tstamp_type; /* timestamp type (req. proto >= 2.0.12) */ ++ unsigned char reserved[56]; /* reserved for future */ ++}; ++ ++struct snd_pcm_channel_info { ++ unsigned int channel; ++ __kernel_off_t offset; /* mmap offset */ ++ unsigned int first; /* offset to first sample in bits */ ++ unsigned int step; /* samples distance in bits */ ++}; ++ ++enum { ++ /* ++ * first definition for backwards compatibility only, ++ * maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else ++ */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0, ++ ++ /* timestamp definitions */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1, /* DMA time, reported as per hw_ptr */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2, /* link time reported by sample or wallclock counter, reset on startup */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3, /* link time reported by sample or wallclock counter, not reset on startup */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4, /* link time estimated indirectly */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, /* link time synchronized with system time */ ++ SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED ++}; ++ ++struct snd_pcm_status { ++ snd_pcm_state_t state; /* stream state */ ++ struct timespec trigger_tstamp; /* time when stream was started/stopped/paused */ ++ struct timespec tstamp; /* reference timestamp */ ++ snd_pcm_uframes_t appl_ptr; /* appl ptr */ ++ snd_pcm_uframes_t hw_ptr; /* hw ptr */ ++ snd_pcm_sframes_t delay; /* current delay in frames */ ++ snd_pcm_uframes_t avail; /* number of frames available */ ++ snd_pcm_uframes_t avail_max; /* max frames available on hw since last status */ ++ snd_pcm_uframes_t overrange; /* count of ADC (capture) overrange detections from last status */ ++ snd_pcm_state_t suspended_state; /* suspended stream state */ ++ __u32 audio_tstamp_data; /* needed for 64-bit alignment, used for configs/report to/from userspace */ ++ struct timespec audio_tstamp; /* sample counter, wall clock, PHC or on-demand sync'ed */ ++ struct timespec driver_tstamp; /* useful in case reference system tstamp is reported with delay */ ++ __u32 audio_tstamp_accuracy; /* in ns units, only valid if indicated in audio_tstamp_data */ ++ unsigned char reserved[52-2*sizeof(struct timespec)]; /* must be filled with zero */ ++}; ++ ++struct snd_pcm_mmap_status { ++ snd_pcm_state_t state; /* RO: state - SNDRV_PCM_STATE_XXXX */ ++ int pad1; /* Needed for 64 bit alignment */ ++ snd_pcm_uframes_t hw_ptr; /* RO: hw ptr (0...boundary-1) */ ++ struct timespec tstamp; /* Timestamp */ ++ snd_pcm_state_t suspended_state; /* RO: suspended stream state */ ++ struct timespec audio_tstamp; /* from sample counter or wall clock */ ++}; ++ ++struct snd_pcm_mmap_control { ++ snd_pcm_uframes_t appl_ptr; /* RW: appl ptr (0...boundary-1) */ ++ snd_pcm_uframes_t avail_min; /* RW: min available frames for wakeup */ ++}; ++ ++#define SNDRV_PCM_SYNC_PTR_HWSYNC (1<<0) /* execute hwsync */ ++#define SNDRV_PCM_SYNC_PTR_APPL (1<<1) /* get appl_ptr from driver (r/w op) */ ++#define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1<<2) /* get avail_min from driver */ ++ ++struct snd_pcm_sync_ptr { ++ unsigned int flags; ++ union { ++ struct snd_pcm_mmap_status status; ++ unsigned char reserved[64]; ++ } s; ++ union { ++ struct snd_pcm_mmap_control control; ++ unsigned char reserved[64]; ++ } c; ++}; ++ ++struct snd_xferi { ++ snd_pcm_sframes_t result; ++ void __user *buf; ++ snd_pcm_uframes_t frames; ++}; ++ ++struct snd_xfern { ++ snd_pcm_sframes_t result; ++ void __user * __user *bufs; ++ snd_pcm_uframes_t frames; ++}; ++ ++enum { ++ SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, /* gettimeofday equivalent */ ++ SNDRV_PCM_TSTAMP_TYPE_MONOTONIC, /* posix_clock_monotonic equivalent */ ++ SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, /* monotonic_raw (no NTP) */ ++ SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, ++}; ++ ++/* channel positions */ ++enum { ++ SNDRV_CHMAP_UNKNOWN = 0, ++ SNDRV_CHMAP_NA, /* N/A, silent */ ++ SNDRV_CHMAP_MONO, /* mono stream */ ++ /* this follows the alsa-lib mixer channel value + 3 */ ++ SNDRV_CHMAP_FL, /* front left */ ++ SNDRV_CHMAP_FR, /* front right */ ++ SNDRV_CHMAP_RL, /* rear left */ ++ SNDRV_CHMAP_RR, /* rear right */ ++ SNDRV_CHMAP_FC, /* front center */ ++ SNDRV_CHMAP_LFE, /* LFE */ ++ SNDRV_CHMAP_SL, /* side left */ ++ SNDRV_CHMAP_SR, /* side right */ ++ SNDRV_CHMAP_RC, /* rear center */ ++ /* new definitions */ ++ SNDRV_CHMAP_FLC, /* front left center */ ++ SNDRV_CHMAP_FRC, /* front right center */ ++ SNDRV_CHMAP_RLC, /* rear left center */ ++ SNDRV_CHMAP_RRC, /* rear right center */ ++ SNDRV_CHMAP_FLW, /* front left wide */ ++ SNDRV_CHMAP_FRW, /* front right wide */ ++ SNDRV_CHMAP_FLH, /* front left high */ ++ SNDRV_CHMAP_FCH, /* front center high */ ++ SNDRV_CHMAP_FRH, /* front right high */ ++ SNDRV_CHMAP_TC, /* top center */ ++ SNDRV_CHMAP_TFL, /* top front left */ ++ SNDRV_CHMAP_TFR, /* top front right */ ++ SNDRV_CHMAP_TFC, /* top front center */ ++ SNDRV_CHMAP_TRL, /* top rear left */ ++ SNDRV_CHMAP_TRR, /* top rear right */ ++ SNDRV_CHMAP_TRC, /* top rear center */ ++ /* new definitions for UAC2 */ ++ SNDRV_CHMAP_TFLC, /* top front left center */ ++ SNDRV_CHMAP_TFRC, /* top front right center */ ++ SNDRV_CHMAP_TSL, /* top side left */ ++ SNDRV_CHMAP_TSR, /* top side right */ ++ SNDRV_CHMAP_LLFE, /* left LFE */ ++ SNDRV_CHMAP_RLFE, /* right LFE */ ++ SNDRV_CHMAP_BC, /* bottom center */ ++ SNDRV_CHMAP_BLC, /* bottom left center */ ++ SNDRV_CHMAP_BRC, /* bottom right center */ ++ SNDRV_CHMAP_LAST = SNDRV_CHMAP_BRC, ++}; ++ ++#define SNDRV_CHMAP_POSITION_MASK 0xffff ++#define SNDRV_CHMAP_PHASE_INVERSE (0x01 << 16) ++#define SNDRV_CHMAP_DRIVER_SPEC (0x02 << 16) ++ ++#define SNDRV_PCM_IOCTL_PVERSION _IOR('A', 0x00, int) ++#define SNDRV_PCM_IOCTL_INFO _IOR('A', 0x01, struct snd_pcm_info) ++#define SNDRV_PCM_IOCTL_TSTAMP _IOW('A', 0x02, int) ++#define SNDRV_PCM_IOCTL_TTSTAMP _IOW('A', 0x03, int) ++#define SNDRV_PCM_IOCTL_USER_PVERSION _IOW('A', 0x04, int) ++#define SNDRV_PCM_IOCTL_HW_REFINE _IOWR('A', 0x10, struct snd_pcm_hw_params) ++#define SNDRV_PCM_IOCTL_HW_PARAMS _IOWR('A', 0x11, struct snd_pcm_hw_params) ++#define SNDRV_PCM_IOCTL_HW_FREE _IO('A', 0x12) ++#define SNDRV_PCM_IOCTL_SW_PARAMS _IOWR('A', 0x13, struct snd_pcm_sw_params) ++#define SNDRV_PCM_IOCTL_STATUS _IOR('A', 0x20, struct snd_pcm_status) ++#define SNDRV_PCM_IOCTL_DELAY _IOR('A', 0x21, snd_pcm_sframes_t) ++#define SNDRV_PCM_IOCTL_HWSYNC _IO('A', 0x22) ++#define SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct snd_pcm_sync_ptr) ++#define SNDRV_PCM_IOCTL_STATUS_EXT _IOWR('A', 0x24, struct snd_pcm_status) ++#define SNDRV_PCM_IOCTL_CHANNEL_INFO _IOR('A', 0x32, struct snd_pcm_channel_info) ++#define SNDRV_PCM_IOCTL_PREPARE _IO('A', 0x40) ++#define SNDRV_PCM_IOCTL_RESET _IO('A', 0x41) ++#define SNDRV_PCM_IOCTL_START _IO('A', 0x42) ++#define SNDRV_PCM_IOCTL_DROP _IO('A', 0x43) ++#define SNDRV_PCM_IOCTL_DRAIN _IO('A', 0x44) ++#define SNDRV_PCM_IOCTL_PAUSE _IOW('A', 0x45, int) ++#define SNDRV_PCM_IOCTL_REWIND _IOW('A', 0x46, snd_pcm_uframes_t) ++#define SNDRV_PCM_IOCTL_RESUME _IO('A', 0x47) ++#define SNDRV_PCM_IOCTL_XRUN _IO('A', 0x48) ++#define SNDRV_PCM_IOCTL_FORWARD _IOW('A', 0x49, snd_pcm_uframes_t) ++#define SNDRV_PCM_IOCTL_WRITEI_FRAMES _IOW('A', 0x50, struct snd_xferi) ++#define SNDRV_PCM_IOCTL_READI_FRAMES _IOR('A', 0x51, struct snd_xferi) ++#define SNDRV_PCM_IOCTL_WRITEN_FRAMES _IOW('A', 0x52, struct snd_xfern) ++#define SNDRV_PCM_IOCTL_READN_FRAMES _IOR('A', 0x53, struct snd_xfern) ++#define SNDRV_PCM_IOCTL_LINK _IOW('A', 0x60, int) ++#define SNDRV_PCM_IOCTL_UNLINK _IO('A', 0x61) ++ ++/***************************************************************************** ++ * * ++ * MIDI v1.0 interface * ++ * * ++ *****************************************************************************/ ++ ++/* ++ * Raw MIDI section - /dev/snd/midi?? ++ */ ++ ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 0) ++ ++enum { ++ SNDRV_RAWMIDI_STREAM_OUTPUT = 0, ++ SNDRV_RAWMIDI_STREAM_INPUT, ++ SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT, ++}; ++ ++#define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 ++#define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 ++#define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++ ++struct snd_rawmidi_info { ++ unsigned int device; /* RO/WR (control): device number */ ++ unsigned int subdevice; /* RO/WR (control): subdevice number */ ++ int stream; /* WR: stream */ ++ int card; /* R: card number */ ++ unsigned int flags; /* SNDRV_RAWMIDI_INFO_XXXX */ ++ unsigned char id[64]; /* ID (user selectable) */ ++ unsigned char name[80]; /* name of device */ ++ unsigned char subname[32]; /* name of active or selected subdevice */ ++ unsigned int subdevices_count; ++ unsigned int subdevices_avail; ++ unsigned char reserved[64]; /* reserved for future use */ ++}; ++ ++struct snd_rawmidi_params { ++ int stream; ++ size_t buffer_size; /* queue size in bytes */ ++ size_t avail_min; /* minimum avail bytes for wakeup */ ++ unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */ ++ unsigned char reserved[16]; /* reserved for future use */ ++}; ++ ++struct snd_rawmidi_status { ++ int stream; ++ struct timespec tstamp; /* Timestamp */ ++ size_t avail; /* available bytes */ ++ size_t xruns; /* count of overruns since last status (in bytes) */ ++ unsigned char reserved[16]; /* reserved for future use */ ++}; ++ ++#define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) ++#define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) ++#define SNDRV_RAWMIDI_IOCTL_PARAMS _IOWR('W', 0x10, struct snd_rawmidi_params) ++#define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) ++#define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) ++#define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++ ++/* ++ * Timer section - /dev/snd/timer ++ */ ++ ++#define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 6) ++ ++enum { ++ SNDRV_TIMER_CLASS_NONE = -1, ++ SNDRV_TIMER_CLASS_SLAVE = 0, ++ SNDRV_TIMER_CLASS_GLOBAL, ++ SNDRV_TIMER_CLASS_CARD, ++ SNDRV_TIMER_CLASS_PCM, ++ SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM, ++}; ++ ++/* slave timer classes */ ++enum { ++ SNDRV_TIMER_SCLASS_NONE = 0, ++ SNDRV_TIMER_SCLASS_APPLICATION, ++ SNDRV_TIMER_SCLASS_SEQUENCER, /* alias */ ++ SNDRV_TIMER_SCLASS_OSS_SEQUENCER, /* alias */ ++ SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER, ++}; ++ ++/* global timers (device member) */ ++#define SNDRV_TIMER_GLOBAL_SYSTEM 0 ++#define SNDRV_TIMER_GLOBAL_RTC 1 /* unused */ ++#define SNDRV_TIMER_GLOBAL_HPET 2 ++#define SNDRV_TIMER_GLOBAL_HRTIMER 3 ++ ++/* info flags */ ++#define SNDRV_TIMER_FLG_SLAVE (1<<0) /* cannot be controlled */ ++ ++struct snd_timer_id { ++ int dev_class; ++ int dev_sclass; ++ int card; ++ int device; ++ int subdevice; ++}; ++ ++struct snd_timer_ginfo { ++ struct snd_timer_id tid; /* requested timer ID */ ++ unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ ++ int card; /* card number */ ++ unsigned char id[64]; /* timer identification */ ++ unsigned char name[80]; /* timer name */ ++ unsigned long reserved0; /* reserved for future use */ ++ unsigned long resolution; /* average period resolution in ns */ ++ unsigned long resolution_min; /* minimal period resolution in ns */ ++ unsigned long resolution_max; /* maximal period resolution in ns */ ++ unsigned int clients; /* active timer clients */ ++ unsigned char reserved[32]; ++}; ++ ++struct snd_timer_gparams { ++ struct snd_timer_id tid; /* requested timer ID */ ++ unsigned long period_num; /* requested precise period duration (in seconds) - numerator */ ++ unsigned long period_den; /* requested precise period duration (in seconds) - denominator */ ++ unsigned char reserved[32]; ++}; ++ ++struct snd_timer_gstatus { ++ struct snd_timer_id tid; /* requested timer ID */ ++ unsigned long resolution; /* current period resolution in ns */ ++ unsigned long resolution_num; /* precise current period resolution (in seconds) - numerator */ ++ unsigned long resolution_den; /* precise current period resolution (in seconds) - denominator */ ++ unsigned char reserved[32]; ++}; ++ ++struct snd_timer_select { ++ struct snd_timer_id id; /* bind to timer ID */ ++ unsigned char reserved[32]; /* reserved */ ++}; ++ ++struct snd_timer_info { ++ unsigned int flags; /* timer flags - SNDRV_TIMER_FLG_* */ ++ int card; /* card number */ ++ unsigned char id[64]; /* timer identificator */ ++ unsigned char name[80]; /* timer name */ ++ unsigned long reserved0; /* reserved for future use */ ++ unsigned long resolution; /* average period resolution in ns */ ++ unsigned char reserved[64]; /* reserved */ ++}; ++ ++#define SNDRV_TIMER_PSFLG_AUTO (1<<0) /* auto start, otherwise one-shot */ ++#define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) /* exclusive use, precise start/stop/pause/continue */ ++#define SNDRV_TIMER_PSFLG_EARLY_EVENT (1<<2) /* write early event to the poll queue */ ++ ++struct snd_timer_params { ++ unsigned int flags; /* flags - SNDRV_TIMER_PSFLG_* */ ++ unsigned int ticks; /* requested resolution in ticks */ ++ unsigned int queue_size; /* total size of queue (32-1024) */ ++ unsigned int reserved0; /* reserved, was: failure locations */ ++ unsigned int filter; /* event filter (bitmask of SNDRV_TIMER_EVENT_*) */ ++ unsigned char reserved[60]; /* reserved */ ++}; ++ ++struct snd_timer_status { ++ struct timespec tstamp; /* Timestamp - last update */ ++ unsigned int resolution; /* current period resolution in ns */ ++ unsigned int lost; /* counter of master tick lost */ ++ unsigned int overrun; /* count of read queue overruns */ ++ unsigned int queue; /* used queue size */ ++ unsigned char reserved[64]; /* reserved */ ++}; ++ ++#define SNDRV_TIMER_IOCTL_PVERSION _IOR('T', 0x00, int) ++#define SNDRV_TIMER_IOCTL_NEXT_DEVICE _IOWR('T', 0x01, struct snd_timer_id) ++#define SNDRV_TIMER_IOCTL_TREAD _IOW('T', 0x02, int) ++#define SNDRV_TIMER_IOCTL_GINFO _IOWR('T', 0x03, struct snd_timer_ginfo) ++#define SNDRV_TIMER_IOCTL_GPARAMS _IOW('T', 0x04, struct snd_timer_gparams) ++#define SNDRV_TIMER_IOCTL_GSTATUS _IOWR('T', 0x05, struct snd_timer_gstatus) ++#define SNDRV_TIMER_IOCTL_SELECT _IOW('T', 0x10, struct snd_timer_select) ++#define SNDRV_TIMER_IOCTL_INFO _IOR('T', 0x11, struct snd_timer_info) ++#define SNDRV_TIMER_IOCTL_PARAMS _IOW('T', 0x12, struct snd_timer_params) ++#define SNDRV_TIMER_IOCTL_STATUS _IOR('T', 0x14, struct snd_timer_status) ++/* The following four ioctls are changed since 1.0.9 due to confliction */ ++#define SNDRV_TIMER_IOCTL_START _IO('T', 0xa0) ++#define SNDRV_TIMER_IOCTL_STOP _IO('T', 0xa1) ++#define SNDRV_TIMER_IOCTL_CONTINUE _IO('T', 0xa2) ++#define SNDRV_TIMER_IOCTL_PAUSE _IO('T', 0xa3) ++ ++struct snd_timer_read { ++ unsigned int resolution; ++ unsigned int ticks; ++}; ++ ++enum { ++ SNDRV_TIMER_EVENT_RESOLUTION = 0, /* val = resolution in ns */ ++ SNDRV_TIMER_EVENT_TICK, /* val = ticks */ ++ SNDRV_TIMER_EVENT_START, /* val = resolution in ns */ ++ SNDRV_TIMER_EVENT_STOP, /* val = 0 */ ++ SNDRV_TIMER_EVENT_CONTINUE, /* val = resolution in ns */ ++ SNDRV_TIMER_EVENT_PAUSE, /* val = 0 */ ++ SNDRV_TIMER_EVENT_EARLY, /* val = 0, early event */ ++ SNDRV_TIMER_EVENT_SUSPEND, /* val = 0 */ ++ SNDRV_TIMER_EVENT_RESUME, /* val = resolution in ns */ ++ /* master timer events for slave timer instances */ ++ SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10, ++ SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10, ++ SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10, ++ SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10, ++ SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10, ++ SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10, ++}; ++ ++struct snd_timer_tread { ++ int event; ++ struct timespec tstamp; ++ unsigned int val; ++}; ++ ++/**************************************************************************** ++ * * ++ * Section for driver control interface - /dev/snd/control? * ++ * * ++ ****************************************************************************/ ++ ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 7) ++ ++struct snd_ctl_card_info { ++ int card; /* card number */ ++ int pad; /* reserved for future (was type) */ ++ unsigned char id[16]; /* ID of card (user selectable) */ ++ unsigned char driver[16]; /* Driver name */ ++ unsigned char name[32]; /* Short name of soundcard */ ++ unsigned char longname[80]; /* name + info text about soundcard */ ++ unsigned char reserved_[16]; /* reserved for future (was ID of mixer) */ ++ unsigned char mixername[80]; /* visual mixer identification */ ++ unsigned char components[128]; /* card components / fine identification, delimited with one space (AC97 etc..) */ ++}; ++ ++typedef int __bitwise snd_ctl_elem_type_t; ++#define SNDRV_CTL_ELEM_TYPE_NONE ((__force snd_ctl_elem_type_t) 0) /* invalid */ ++#define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((__force snd_ctl_elem_type_t) 1) /* boolean type */ ++#define SNDRV_CTL_ELEM_TYPE_INTEGER ((__force snd_ctl_elem_type_t) 2) /* integer type */ ++#define SNDRV_CTL_ELEM_TYPE_ENUMERATED ((__force snd_ctl_elem_type_t) 3) /* enumerated type */ ++#define SNDRV_CTL_ELEM_TYPE_BYTES ((__force snd_ctl_elem_type_t) 4) /* byte array */ ++#define SNDRV_CTL_ELEM_TYPE_IEC958 ((__force snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */ ++#define SNDRV_CTL_ELEM_TYPE_INTEGER64 ((__force snd_ctl_elem_type_t) 6) /* 64-bit integer type */ ++#define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 ++ ++typedef int __bitwise snd_ctl_elem_iface_t; ++#define SNDRV_CTL_ELEM_IFACE_CARD ((__force snd_ctl_elem_iface_t) 0) /* global control */ ++#define SNDRV_CTL_ELEM_IFACE_HWDEP ((__force snd_ctl_elem_iface_t) 1) /* hardware dependent device */ ++#define SNDRV_CTL_ELEM_IFACE_MIXER ((__force snd_ctl_elem_iface_t) 2) /* virtual mixer device */ ++#define SNDRV_CTL_ELEM_IFACE_PCM ((__force snd_ctl_elem_iface_t) 3) /* PCM device */ ++#define SNDRV_CTL_ELEM_IFACE_RAWMIDI ((__force snd_ctl_elem_iface_t) 4) /* RawMidi device */ ++#define SNDRV_CTL_ELEM_IFACE_TIMER ((__force snd_ctl_elem_iface_t) 5) /* timer device */ ++#define SNDRV_CTL_ELEM_IFACE_SEQUENCER ((__force snd_ctl_elem_iface_t) 6) /* sequencer client */ ++#define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER ++ ++#define SNDRV_CTL_ELEM_ACCESS_READ (1<<0) ++#define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1) ++#define SNDRV_CTL_ELEM_ACCESS_READWRITE (SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE) ++#define SNDRV_CTL_ELEM_ACCESS_VOLATILE (1<<2) /* control value may be changed without a notification */ ++#define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP (1<<3) /* when was control changed */ ++#define SNDRV_CTL_ELEM_ACCESS_TLV_READ (1<<4) /* TLV read is possible */ ++#define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE (1<<5) /* TLV write is possible */ ++#define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE (SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) ++#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND (1<<6) /* TLV command is possible */ ++#define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) /* control does actually nothing, but may be updated */ ++#define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) /* write lock */ ++#define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) /* write lock owner */ ++#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) /* kernel use a TLV callback */ ++#define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) /* user space element */ ++/* bits 30 and 31 are obsoleted (for indirect access) */ ++ ++/* for further details see the ACPI and PCI power management specification */ ++#define SNDRV_CTL_POWER_D0 0x0000 /* full On */ ++#define SNDRV_CTL_POWER_D1 0x0100 /* partial On */ ++#define SNDRV_CTL_POWER_D2 0x0200 /* partial On */ ++#define SNDRV_CTL_POWER_D3 0x0300 /* Off */ ++#define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3|0x0000) /* Off, with power */ ++#define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3|0x0001) /* Off, without power */ ++ ++#define SNDRV_CTL_ELEM_ID_NAME_MAXLEN 44 ++ ++struct snd_ctl_elem_id { ++ unsigned int numid; /* numeric identifier, zero = invalid */ ++ snd_ctl_elem_iface_t iface; /* interface identifier */ ++ unsigned int device; /* device/client number */ ++ unsigned int subdevice; /* subdevice (substream) number */ ++ unsigned char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* ASCII name of item */ ++ unsigned int index; /* index of item */ ++}; ++ ++struct snd_ctl_elem_list { ++ unsigned int offset; /* W: first element ID to get */ ++ unsigned int space; /* W: count of element IDs to get */ ++ unsigned int used; /* R: count of element IDs set */ ++ unsigned int count; /* R: count of all elements */ ++ struct snd_ctl_elem_id __user *pids; /* R: IDs */ ++ unsigned char reserved[50]; ++}; ++ ++struct snd_ctl_elem_info { ++ struct snd_ctl_elem_id id; /* W: element ID */ ++ snd_ctl_elem_type_t type; /* R: value type - SNDRV_CTL_ELEM_TYPE_* */ ++ unsigned int access; /* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */ ++ unsigned int count; /* count of values */ ++ __kernel_pid_t owner; /* owner's PID of this control */ ++ union { ++ struct { ++ long min; /* R: minimum value */ ++ long max; /* R: maximum value */ ++ long step; /* R: step (0 variable) */ ++ } integer; ++ struct { ++ long long min; /* R: minimum value */ ++ long long max; /* R: maximum value */ ++ long long step; /* R: step (0 variable) */ ++ } integer64; ++ struct { ++ unsigned int items; /* R: number of items */ ++ unsigned int item; /* W: item number */ ++ char name[64]; /* R: value name */ ++ __u64 names_ptr; /* W: names list (ELEM_ADD only) */ ++ unsigned int names_length; ++ } enumerated; ++ unsigned char reserved[128]; ++ } value; ++ union { ++ unsigned short d[4]; /* dimensions */ ++ unsigned short *d_ptr; /* indirect - obsoleted */ ++ } dimen; ++ unsigned char reserved[64-4*sizeof(unsigned short)]; ++}; ++ ++struct snd_ctl_elem_value { ++ struct snd_ctl_elem_id id; /* W: element ID */ ++ unsigned int indirect: 1; /* W: indirect access - obsoleted */ ++ union { ++ union { ++ long value[128]; ++ long *value_ptr; /* obsoleted */ ++ } integer; ++ union { ++ long long value[64]; ++ long long *value_ptr; /* obsoleted */ ++ } integer64; ++ union { ++ unsigned int item[128]; ++ unsigned int *item_ptr; /* obsoleted */ ++ } enumerated; ++ union { ++ unsigned char data[512]; ++ unsigned char *data_ptr; /* obsoleted */ ++ } bytes; ++ struct snd_aes_iec958 iec958; ++ } value; /* RO */ ++ struct timespec tstamp; ++ unsigned char reserved[128-sizeof(struct timespec)]; ++}; ++ ++struct snd_ctl_tlv { ++ unsigned int numid; /* control element numeric identification */ ++ unsigned int length; /* in bytes aligned to 4 */ ++ unsigned int tlv[0]; /* first TLV */ ++}; ++ ++#define SNDRV_CTL_IOCTL_PVERSION _IOR('U', 0x00, int) ++#define SNDRV_CTL_IOCTL_CARD_INFO _IOR('U', 0x01, struct snd_ctl_card_info) ++#define SNDRV_CTL_IOCTL_ELEM_LIST _IOWR('U', 0x10, struct snd_ctl_elem_list) ++#define SNDRV_CTL_IOCTL_ELEM_INFO _IOWR('U', 0x11, struct snd_ctl_elem_info) ++#define SNDRV_CTL_IOCTL_ELEM_READ _IOWR('U', 0x12, struct snd_ctl_elem_value) ++#define SNDRV_CTL_IOCTL_ELEM_WRITE _IOWR('U', 0x13, struct snd_ctl_elem_value) ++#define SNDRV_CTL_IOCTL_ELEM_LOCK _IOW('U', 0x14, struct snd_ctl_elem_id) ++#define SNDRV_CTL_IOCTL_ELEM_UNLOCK _IOW('U', 0x15, struct snd_ctl_elem_id) ++#define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int) ++#define SNDRV_CTL_IOCTL_ELEM_ADD _IOWR('U', 0x17, struct snd_ctl_elem_info) ++#define SNDRV_CTL_IOCTL_ELEM_REPLACE _IOWR('U', 0x18, struct snd_ctl_elem_info) ++#define SNDRV_CTL_IOCTL_ELEM_REMOVE _IOWR('U', 0x19, struct snd_ctl_elem_id) ++#define SNDRV_CTL_IOCTL_TLV_READ _IOWR('U', 0x1a, struct snd_ctl_tlv) ++#define SNDRV_CTL_IOCTL_TLV_WRITE _IOWR('U', 0x1b, struct snd_ctl_tlv) ++#define SNDRV_CTL_IOCTL_TLV_COMMAND _IOWR('U', 0x1c, struct snd_ctl_tlv) ++#define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int) ++#define SNDRV_CTL_IOCTL_HWDEP_INFO _IOR('U', 0x21, struct snd_hwdep_info) ++#define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int) ++#define SNDRV_CTL_IOCTL_PCM_INFO _IOWR('U', 0x31, struct snd_pcm_info) ++#define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int) ++#define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) ++#define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) ++#define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) ++#define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) ++ ++/* ++ * Read interface. ++ */ ++ ++enum sndrv_ctl_event_type { ++ SNDRV_CTL_EVENT_ELEM = 0, ++ SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM, ++}; ++ ++#define SNDRV_CTL_EVENT_MASK_VALUE (1<<0) /* element value was changed */ ++#define SNDRV_CTL_EVENT_MASK_INFO (1<<1) /* element info was changed */ ++#define SNDRV_CTL_EVENT_MASK_ADD (1<<2) /* element was added */ ++#define SNDRV_CTL_EVENT_MASK_TLV (1<<3) /* element TLV tree was changed */ ++#define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) /* element was removed */ ++ ++struct snd_ctl_event { ++ int type; /* event type - SNDRV_CTL_EVENT_* */ ++ union { ++ struct { ++ unsigned int mask; ++ struct snd_ctl_elem_id id; ++ } elem; ++ unsigned char data8[60]; ++ } data; ++}; ++ ++/* ++ * Control names ++ */ ++ ++#define SNDRV_CTL_NAME_NONE "" ++#define SNDRV_CTL_NAME_PLAYBACK "Playback " ++#define SNDRV_CTL_NAME_CAPTURE "Capture " ++ ++#define SNDRV_CTL_NAME_IEC958_NONE "" ++#define SNDRV_CTL_NAME_IEC958_SWITCH "Switch" ++#define SNDRV_CTL_NAME_IEC958_VOLUME "Volume" ++#define SNDRV_CTL_NAME_IEC958_DEFAULT "Default" ++#define SNDRV_CTL_NAME_IEC958_MASK "Mask" ++#define SNDRV_CTL_NAME_IEC958_CON_MASK "Con Mask" ++#define SNDRV_CTL_NAME_IEC958_PRO_MASK "Pro Mask" ++#define SNDRV_CTL_NAME_IEC958_PCM_STREAM "PCM Stream" ++#define SNDRV_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what ++ ++#endif /* _UAPI__SOUND_ASOUND_H */ +diff --git a/include/sound/uapi/asound_fm.h b/include/sound/uapi/asound_fm.h +new file mode 100644 +index 000000000000..8471f404ff0b +--- /dev/null ++++ b/include/sound/uapi/asound_fm.h +@@ -0,0 +1,135 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++#ifndef __SOUND_ASOUND_FM_H ++#define __SOUND_ASOUND_FM_H ++ ++/* ++ * Advanced Linux Sound Architecture - ALSA ++ * ++ * Interface file between ALSA driver & user space ++ * Copyright (c) 1994-98 by Jaroslav Kysela , ++ * 4Front Technologies ++ * ++ * Direct FM control ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ */ ++ ++#define SNDRV_DM_FM_MODE_OPL2 0x00 ++#define SNDRV_DM_FM_MODE_OPL3 0x01 ++ ++struct snd_dm_fm_info { ++ unsigned char fm_mode; /* OPL mode, see SNDRV_DM_FM_MODE_XXX */ ++ unsigned char rhythm; /* percussion mode flag */ ++}; ++ ++/* ++ * Data structure composing an FM "note" or sound event. ++ */ ++ ++struct snd_dm_fm_voice { ++ unsigned char op; /* operator cell (0 or 1) */ ++ unsigned char voice; /* FM voice (0 to 17) */ ++ ++ unsigned char am; /* amplitude modulation */ ++ unsigned char vibrato; /* vibrato effect */ ++ unsigned char do_sustain; /* sustain phase */ ++ unsigned char kbd_scale; /* keyboard scaling */ ++ unsigned char harmonic; /* 4 bits: harmonic and multiplier */ ++ unsigned char scale_level; /* 2 bits: decrease output freq rises */ ++ unsigned char volume; /* 6 bits: volume */ ++ ++ unsigned char attack; /* 4 bits: attack rate */ ++ unsigned char decay; /* 4 bits: decay rate */ ++ unsigned char sustain; /* 4 bits: sustain level */ ++ unsigned char release; /* 4 bits: release rate */ ++ ++ unsigned char feedback; /* 3 bits: feedback for op0 */ ++ unsigned char connection; /* 0 for serial, 1 for parallel */ ++ unsigned char left; /* stereo left */ ++ unsigned char right; /* stereo right */ ++ unsigned char waveform; /* 3 bits: waveform shape */ ++}; ++ ++/* ++ * This describes an FM note by its voice, octave, frequency number (10bit) ++ * and key on/off. ++ */ ++ ++struct snd_dm_fm_note { ++ unsigned char voice; /* 0-17 voice channel */ ++ unsigned char octave; /* 3 bits: what octave to play */ ++ unsigned int fnum; /* 10 bits: frequency number */ ++ unsigned char key_on; /* set for active, clear for silent */ ++}; ++ ++/* ++ * FM parameters that apply globally to all voices, and thus are not "notes" ++ */ ++ ++struct snd_dm_fm_params { ++ unsigned char am_depth; /* amplitude modulation depth (1=hi) */ ++ unsigned char vib_depth; /* vibrato depth (1=hi) */ ++ unsigned char kbd_split; /* keyboard split */ ++ unsigned char rhythm; /* percussion mode select */ ++ ++ /* This block is the percussion instrument data */ ++ unsigned char bass; ++ unsigned char snare; ++ unsigned char tomtom; ++ unsigned char cymbal; ++ unsigned char hihat; ++}; ++ ++/* ++ * FM mode ioctl settings ++ */ ++ ++#define SNDRV_DM_FM_IOCTL_INFO _IOR('H', 0x20, struct snd_dm_fm_info) ++#define SNDRV_DM_FM_IOCTL_RESET _IO ('H', 0x21) ++#define SNDRV_DM_FM_IOCTL_PLAY_NOTE _IOW('H', 0x22, struct snd_dm_fm_note) ++#define SNDRV_DM_FM_IOCTL_SET_VOICE _IOW('H', 0x23, struct snd_dm_fm_voice) ++#define SNDRV_DM_FM_IOCTL_SET_PARAMS _IOW('H', 0x24, struct snd_dm_fm_params) ++#define SNDRV_DM_FM_IOCTL_SET_MODE _IOW('H', 0x25, int) ++/* for OPL3 only */ ++#define SNDRV_DM_FM_IOCTL_SET_CONNECTION _IOW('H', 0x26, int) ++/* SBI patch management */ ++#define SNDRV_DM_FM_IOCTL_CLEAR_PATCHES _IO ('H', 0x40) ++ ++#define SNDRV_DM_FM_OSS_IOCTL_RESET 0x20 ++#define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE 0x21 ++#define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE 0x22 ++#define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS 0x23 ++#define SNDRV_DM_FM_OSS_IOCTL_SET_MODE 0x24 ++#define SNDRV_DM_FM_OSS_IOCTL_SET_OPL 0x25 ++ ++/* ++ * Patch Record - fixed size for write ++ */ ++ ++#define FM_KEY_SBI "SBI\032" ++#define FM_KEY_2OP "2OP\032" ++#define FM_KEY_4OP "4OP\032" ++ ++struct sbi_patch { ++ unsigned char prog; ++ unsigned char bank; ++ char key[4]; ++ char name[25]; ++ char extension[7]; ++ unsigned char data[32]; ++}; ++ ++#endif /* __SOUND_ASOUND_FM_H */ +diff --git a/include/sound/uapi/emu10k1.h b/include/sound/uapi/emu10k1.h +new file mode 100644 +index 000000000000..c1150e4d0231 +--- /dev/null ++++ b/include/sound/uapi/emu10k1.h +@@ -0,0 +1,395 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++/* ++ * Copyright (c) by Jaroslav Kysela , ++ * Creative Labs, Inc. ++ * Definitions for EMU10K1 (SB Live!) chips ++ * ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ */ ++#ifndef _UAPI__SOUND_EMU10K1_H ++#define _UAPI__SOUND_EMU10K1_H ++ ++/* ++ * ---- FX8010 ---- ++ */ ++ ++#define EMU10K1_CARD_CREATIVE 0x00000000 ++#define EMU10K1_CARD_EMUAPS 0x00000001 ++ ++#define EMU10K1_FX8010_PCM_COUNT 8 ++ ++/* ++ * Following definition is copied from linux/types.h to support compiling ++ * this header file in userspace since they are not generally available for ++ * uapi headers. ++ */ ++#define __EMU10K1_DECLARE_BITMAP(name,bits) \ ++ unsigned long name[(bits) / (sizeof(unsigned long) * 8)] ++ ++/* instruction set */ ++#define iMAC0 0x00 /* R = A + (X * Y >> 31) ; saturation */ ++#define iMAC1 0x01 /* R = A + (-X * Y >> 31) ; saturation */ ++#define iMAC2 0x02 /* R = A + (X * Y >> 31) ; wraparound */ ++#define iMAC3 0x03 /* R = A + (-X * Y >> 31) ; wraparound */ ++#define iMACINT0 0x04 /* R = A + X * Y ; saturation */ ++#define iMACINT1 0x05 /* R = A + X * Y ; wraparound (31-bit) */ ++#define iACC3 0x06 /* R = A + X + Y ; saturation */ ++#define iMACMV 0x07 /* R = A, acc += X * Y >> 31 */ ++#define iANDXOR 0x08 /* R = (A & X) ^ Y */ ++#define iTSTNEG 0x09 /* R = (A >= Y) ? X : ~X */ ++#define iLIMITGE 0x0a /* R = (A >= Y) ? X : Y */ ++#define iLIMITLT 0x0b /* R = (A < Y) ? X : Y */ ++#define iLOG 0x0c /* R = linear_data, A (log_data), X (max_exp), Y (format_word) */ ++#define iEXP 0x0d /* R = log_data, A (linear_data), X (max_exp), Y (format_word) */ ++#define iINTERP 0x0e /* R = A + (X * (Y - A) >> 31) ; saturation */ ++#define iSKIP 0x0f /* R = A (cc_reg), X (count), Y (cc_test) */ ++ ++/* GPRs */ ++#define FXBUS(x) (0x00 + (x)) /* x = 0x00 - 0x0f */ ++#define EXTIN(x) (0x10 + (x)) /* x = 0x00 - 0x0f */ ++#define EXTOUT(x) (0x20 + (x)) /* x = 0x00 - 0x0f physical outs -> FXWC low 16 bits */ ++#define FXBUS2(x) (0x30 + (x)) /* x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits */ ++ /* NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 */ ++ ++#define C_00000000 0x40 ++#define C_00000001 0x41 ++#define C_00000002 0x42 ++#define C_00000003 0x43 ++#define C_00000004 0x44 ++#define C_00000008 0x45 ++#define C_00000010 0x46 ++#define C_00000020 0x47 ++#define C_00000100 0x48 ++#define C_00010000 0x49 ++#define C_00080000 0x4a ++#define C_10000000 0x4b ++#define C_20000000 0x4c ++#define C_40000000 0x4d ++#define C_80000000 0x4e ++#define C_7fffffff 0x4f ++#define C_ffffffff 0x50 ++#define C_fffffffe 0x51 ++#define C_c0000000 0x52 ++#define C_4f1bbcdc 0x53 ++#define C_5a7ef9db 0x54 ++#define C_00100000 0x55 /* ?? */ ++#define GPR_ACCU 0x56 /* ACCUM, accumulator */ ++#define GPR_COND 0x57 /* CCR, condition register */ ++#define GPR_NOISE0 0x58 /* noise source */ ++#define GPR_NOISE1 0x59 /* noise source */ ++#define GPR_IRQ 0x5a /* IRQ register */ ++#define GPR_DBAC 0x5b /* TRAM Delay Base Address Counter */ ++#define GPR(x) (FXGPREGBASE + (x)) /* free GPRs: x = 0x00 - 0xff */ ++#define ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ ++#define ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ ++#define ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */ ++#define ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */ ++ ++#define A_ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ ++#define A_ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ ++#define A_ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ ++#define A_ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ ++#define A_ITRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */ ++#define A_ETRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */ ++ ++#define A_FXBUS(x) (0x00 + (x)) /* x = 0x00 - 0x3f FX buses */ ++#define A_EXTIN(x) (0x40 + (x)) /* x = 0x00 - 0x0f physical ins */ ++#define A_P16VIN(x) (0x50 + (x)) /* x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" */ ++#define A_EXTOUT(x) (0x60 + (x)) /* x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown */ ++#define A_FXBUS2(x) (0x80 + (x)) /* x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 */ ++#define A_EMU32OUTH(x) (0xa0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" - ??? */ ++#define A_EMU32OUTL(x) (0xb0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_1 - _F" - ??? */ ++#define A3_EMU32IN(x) (0x160 + (x)) /* x = 0x00 - 0x3f "EMU32_IN_00 - _3F" - Only when .device = 0x0008 */ ++#define A3_EMU32OUT(x) (0x1E0 + (x)) /* x = 0x00 - 0x0f "EMU32_OUT_00 - _3F" - Only when .device = 0x0008 */ ++#define A_GPR(x) (A_FXGPREGBASE + (x)) ++ ++/* cc_reg constants */ ++#define CC_REG_NORMALIZED C_00000001 ++#define CC_REG_BORROW C_00000002 ++#define CC_REG_MINUS C_00000004 ++#define CC_REG_ZERO C_00000008 ++#define CC_REG_SATURATE C_00000010 ++#define CC_REG_NONZERO C_00000100 ++ ++/* FX buses */ ++#define FXBUS_PCM_LEFT 0x00 ++#define FXBUS_PCM_RIGHT 0x01 ++#define FXBUS_PCM_LEFT_REAR 0x02 ++#define FXBUS_PCM_RIGHT_REAR 0x03 ++#define FXBUS_MIDI_LEFT 0x04 ++#define FXBUS_MIDI_RIGHT 0x05 ++#define FXBUS_PCM_CENTER 0x06 ++#define FXBUS_PCM_LFE 0x07 ++#define FXBUS_PCM_LEFT_FRONT 0x08 ++#define FXBUS_PCM_RIGHT_FRONT 0x09 ++#define FXBUS_MIDI_REVERB 0x0c ++#define FXBUS_MIDI_CHORUS 0x0d ++#define FXBUS_PCM_LEFT_SIDE 0x0e ++#define FXBUS_PCM_RIGHT_SIDE 0x0f ++#define FXBUS_PT_LEFT 0x14 ++#define FXBUS_PT_RIGHT 0x15 ++ ++/* Inputs */ ++#define EXTIN_AC97_L 0x00 /* AC'97 capture channel - left */ ++#define EXTIN_AC97_R 0x01 /* AC'97 capture channel - right */ ++#define EXTIN_SPDIF_CD_L 0x02 /* internal S/PDIF CD - onboard - left */ ++#define EXTIN_SPDIF_CD_R 0x03 /* internal S/PDIF CD - onboard - right */ ++#define EXTIN_ZOOM_L 0x04 /* Zoom Video I2S - left */ ++#define EXTIN_ZOOM_R 0x05 /* Zoom Video I2S - right */ ++#define EXTIN_TOSLINK_L 0x06 /* LiveDrive - TOSLink Optical - left */ ++#define EXTIN_TOSLINK_R 0x07 /* LiveDrive - TOSLink Optical - right */ ++#define EXTIN_LINE1_L 0x08 /* LiveDrive - Line/Mic 1 - left */ ++#define EXTIN_LINE1_R 0x09 /* LiveDrive - Line/Mic 1 - right */ ++#define EXTIN_COAX_SPDIF_L 0x0a /* LiveDrive - Coaxial S/PDIF - left */ ++#define EXTIN_COAX_SPDIF_R 0x0b /* LiveDrive - Coaxial S/PDIF - right */ ++#define EXTIN_LINE2_L 0x0c /* LiveDrive - Line/Mic 2 - left */ ++#define EXTIN_LINE2_R 0x0d /* LiveDrive - Line/Mic 2 - right */ ++ ++/* Outputs */ ++#define EXTOUT_AC97_L 0x00 /* AC'97 playback channel - left */ ++#define EXTOUT_AC97_R 0x01 /* AC'97 playback channel - right */ ++#define EXTOUT_TOSLINK_L 0x02 /* LiveDrive - TOSLink Optical - left */ ++#define EXTOUT_TOSLINK_R 0x03 /* LiveDrive - TOSLink Optical - right */ ++#define EXTOUT_AC97_CENTER 0x04 /* SB Live 5.1 - center */ ++#define EXTOUT_AC97_LFE 0x05 /* SB Live 5.1 - LFE */ ++#define EXTOUT_HEADPHONE_L 0x06 /* LiveDrive - Headphone - left */ ++#define EXTOUT_HEADPHONE_R 0x07 /* LiveDrive - Headphone - right */ ++#define EXTOUT_REAR_L 0x08 /* Rear channel - left */ ++#define EXTOUT_REAR_R 0x09 /* Rear channel - right */ ++#define EXTOUT_ADC_CAP_L 0x0a /* ADC Capture buffer - left */ ++#define EXTOUT_ADC_CAP_R 0x0b /* ADC Capture buffer - right */ ++#define EXTOUT_MIC_CAP 0x0c /* MIC Capture buffer */ ++#define EXTOUT_AC97_REAR_L 0x0d /* SB Live 5.1 (c) 2003 - Rear Left */ ++#define EXTOUT_AC97_REAR_R 0x0e /* SB Live 5.1 (c) 2003 - Rear Right */ ++#define EXTOUT_ACENTER 0x11 /* Analog Center */ ++#define EXTOUT_ALFE 0x12 /* Analog LFE */ ++ ++/* Audigy Inputs */ ++#define A_EXTIN_AC97_L 0x00 /* AC'97 capture channel - left */ ++#define A_EXTIN_AC97_R 0x01 /* AC'97 capture channel - right */ ++#define A_EXTIN_SPDIF_CD_L 0x02 /* digital CD left */ ++#define A_EXTIN_SPDIF_CD_R 0x03 /* digital CD left */ ++#define A_EXTIN_OPT_SPDIF_L 0x04 /* audigy drive Optical SPDIF - left */ ++#define A_EXTIN_OPT_SPDIF_R 0x05 /* right */ ++#define A_EXTIN_LINE2_L 0x08 /* audigy drive line2/mic2 - left */ ++#define A_EXTIN_LINE2_R 0x09 /* right */ ++#define A_EXTIN_ADC_L 0x0a /* Philips ADC - left */ ++#define A_EXTIN_ADC_R 0x0b /* right */ ++#define A_EXTIN_AUX2_L 0x0c /* audigy drive aux2 - left */ ++#define A_EXTIN_AUX2_R 0x0d /* - right */ ++ ++/* Audigiy Outputs */ ++#define A_EXTOUT_FRONT_L 0x00 /* digital front left */ ++#define A_EXTOUT_FRONT_R 0x01 /* right */ ++#define A_EXTOUT_CENTER 0x02 /* digital front center */ ++#define A_EXTOUT_LFE 0x03 /* digital front lfe */ ++#define A_EXTOUT_HEADPHONE_L 0x04 /* headphone audigy drive left */ ++#define A_EXTOUT_HEADPHONE_R 0x05 /* right */ ++#define A_EXTOUT_REAR_L 0x06 /* digital rear left */ ++#define A_EXTOUT_REAR_R 0x07 /* right */ ++#define A_EXTOUT_AFRONT_L 0x08 /* analog front left */ ++#define A_EXTOUT_AFRONT_R 0x09 /* right */ ++#define A_EXTOUT_ACENTER 0x0a /* analog center */ ++#define A_EXTOUT_ALFE 0x0b /* analog LFE */ ++#define A_EXTOUT_ASIDE_L 0x0c /* analog side left - Audigy 2 ZS */ ++#define A_EXTOUT_ASIDE_R 0x0d /* right - Audigy 2 ZS */ ++#define A_EXTOUT_AREAR_L 0x0e /* analog rear left */ ++#define A_EXTOUT_AREAR_R 0x0f /* right */ ++#define A_EXTOUT_AC97_L 0x10 /* AC97 left (front) */ ++#define A_EXTOUT_AC97_R 0x11 /* right */ ++#define A_EXTOUT_ADC_CAP_L 0x16 /* ADC capture buffer left */ ++#define A_EXTOUT_ADC_CAP_R 0x17 /* right */ ++#define A_EXTOUT_MIC_CAP 0x18 /* Mic capture buffer */ ++ ++/* Audigy constants */ ++#define A_C_00000000 0xc0 ++#define A_C_00000001 0xc1 ++#define A_C_00000002 0xc2 ++#define A_C_00000003 0xc3 ++#define A_C_00000004 0xc4 ++#define A_C_00000008 0xc5 ++#define A_C_00000010 0xc6 ++#define A_C_00000020 0xc7 ++#define A_C_00000100 0xc8 ++#define A_C_00010000 0xc9 ++#define A_C_00000800 0xca ++#define A_C_10000000 0xcb ++#define A_C_20000000 0xcc ++#define A_C_40000000 0xcd ++#define A_C_80000000 0xce ++#define A_C_7fffffff 0xcf ++#define A_C_ffffffff 0xd0 ++#define A_C_fffffffe 0xd1 ++#define A_C_c0000000 0xd2 ++#define A_C_4f1bbcdc 0xd3 ++#define A_C_5a7ef9db 0xd4 ++#define A_C_00100000 0xd5 ++#define A_GPR_ACCU 0xd6 /* ACCUM, accumulator */ ++#define A_GPR_COND 0xd7 /* CCR, condition register */ ++#define A_GPR_NOISE0 0xd8 /* noise source */ ++#define A_GPR_NOISE1 0xd9 /* noise source */ ++#define A_GPR_IRQ 0xda /* IRQ register */ ++#define A_GPR_DBAC 0xdb /* TRAM Delay Base Address Counter - internal */ ++#define A_GPR_DBACE 0xde /* TRAM Delay Base Address Counter - external */ ++ ++/* definitions for debug register */ ++#define EMU10K1_DBG_ZC 0x80000000 /* zero tram counter */ ++#define EMU10K1_DBG_SATURATION_OCCURED 0x02000000 /* saturation control */ ++#define EMU10K1_DBG_SATURATION_ADDR 0x01ff0000 /* saturation address */ ++#define EMU10K1_DBG_SINGLE_STEP 0x00008000 /* single step mode */ ++#define EMU10K1_DBG_STEP 0x00004000 /* start single step */ ++#define EMU10K1_DBG_CONDITION_CODE 0x00003e00 /* condition code */ ++#define EMU10K1_DBG_SINGLE_STEP_ADDR 0x000001ff /* single step address */ ++ ++/* tank memory address line */ ++#ifndef __KERNEL__ ++#define TANKMEMADDRREG_ADDR_MASK 0x000fffff /* 20 bit tank address field */ ++#define TANKMEMADDRREG_CLEAR 0x00800000 /* Clear tank memory */ ++#define TANKMEMADDRREG_ALIGN 0x00400000 /* Align read or write relative to tank access */ ++#define TANKMEMADDRREG_WRITE 0x00200000 /* Write to tank memory */ ++#define TANKMEMADDRREG_READ 0x00100000 /* Read from tank memory */ ++#endif ++ ++struct snd_emu10k1_fx8010_info { ++ unsigned int internal_tram_size; /* in samples */ ++ unsigned int external_tram_size; /* in samples */ ++ char fxbus_names[16][32]; /* names of FXBUSes */ ++ char extin_names[16][32]; /* names of external inputs */ ++ char extout_names[32][32]; /* names of external outputs */ ++ unsigned int gpr_controls; /* count of GPR controls */ ++}; ++ ++#define EMU10K1_GPR_TRANSLATION_NONE 0 ++#define EMU10K1_GPR_TRANSLATION_TABLE100 1 ++#define EMU10K1_GPR_TRANSLATION_BASS 2 ++#define EMU10K1_GPR_TRANSLATION_TREBLE 3 ++#define EMU10K1_GPR_TRANSLATION_ONOFF 4 ++ ++enum emu10k1_ctl_elem_iface { ++ EMU10K1_CTL_ELEM_IFACE_MIXER = 2, /* virtual mixer device */ ++ EMU10K1_CTL_ELEM_IFACE_PCM = 3, /* PCM device */ ++}; ++ ++struct emu10k1_ctl_elem_id { ++ unsigned int pad; /* don't use */ ++ int iface; /* interface identifier */ ++ unsigned int device; /* device/client number */ ++ unsigned int subdevice; /* subdevice (substream) number */ ++ unsigned char name[44]; /* ASCII name of item */ ++ unsigned int index; /* index of item */ ++}; ++ ++struct snd_emu10k1_fx8010_control_gpr { ++ struct emu10k1_ctl_elem_id id; /* full control ID definition */ ++ unsigned int vcount; /* visible count */ ++ unsigned int count; /* count of GPR (1..16) */ ++ unsigned short gpr[32]; /* GPR number(s) */ ++ unsigned int value[32]; /* initial values */ ++ unsigned int min; /* minimum range */ ++ unsigned int max; /* maximum range */ ++ unsigned int translation; /* translation type (EMU10K1_GPR_TRANSLATION*) */ ++ const unsigned int *tlv; ++}; ++ ++/* old ABI without TLV support */ ++struct snd_emu10k1_fx8010_control_old_gpr { ++ struct emu10k1_ctl_elem_id id; ++ unsigned int vcount; ++ unsigned int count; ++ unsigned short gpr[32]; ++ unsigned int value[32]; ++ unsigned int min; ++ unsigned int max; ++ unsigned int translation; ++}; ++ ++struct snd_emu10k1_fx8010_code { ++ char name[128]; ++ ++ __EMU10K1_DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */ ++ __u32 *gpr_map; /* initializers */ ++ ++ unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */ ++ struct snd_emu10k1_fx8010_control_gpr *gpr_add_controls; /* GPR controls to add/replace */ ++ ++ unsigned int gpr_del_control_count; /* count of GPR controls to remove */ ++ struct emu10k1_ctl_elem_id *gpr_del_controls; /* IDs of GPR controls to remove */ ++ ++ unsigned int gpr_list_control_count; /* count of GPR controls to list */ ++ unsigned int gpr_list_control_total; /* total count of GPR controls */ ++ struct snd_emu10k1_fx8010_control_gpr *gpr_list_controls; /* listed GPR controls */ ++ ++ __EMU10K1_DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */ ++ __u32 *tram_data_map; /* data initializers */ ++ __u32 *tram_addr_map; /* map initializers */ ++ ++ __EMU10K1_DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */ ++ __u32 *code; /* one instruction - 64 bits */ ++}; ++ ++struct snd_emu10k1_fx8010_tram { ++ unsigned int address; /* 31.bit == 1 -> external TRAM */ ++ unsigned int size; /* size in samples (4 bytes) */ ++ unsigned int *samples; /* pointer to samples (20-bit) */ ++ /* NULL->clear memory */ ++}; ++ ++struct snd_emu10k1_fx8010_pcm_rec { ++ unsigned int substream; /* substream number */ ++ unsigned int res1; /* reserved */ ++ unsigned int channels; /* 16-bit channels count, zero = remove this substream */ ++ unsigned int tram_start; /* ring buffer position in TRAM (in samples) */ ++ unsigned int buffer_size; /* count of buffered samples */ ++ unsigned short gpr_size; /* GPR containing size of ringbuffer in samples (host) */ ++ unsigned short gpr_ptr; /* GPR containing current pointer in the ring buffer (host = reset, FX8010) */ ++ unsigned short gpr_count; /* GPR containing count of samples between two interrupts (host) */ ++ unsigned short gpr_tmpcount; /* GPR containing current count of samples to interrupt (host = set, FX8010) */ ++ unsigned short gpr_trigger; /* GPR containing trigger (activate) information (host) */ ++ unsigned short gpr_running; /* GPR containing info if PCM is running (FX8010) */ ++ unsigned char pad; /* reserved */ ++ unsigned char etram[32]; /* external TRAM address & data (one per channel) */ ++ unsigned int res2; /* reserved */ ++}; ++ ++#define SNDRV_EMU10K1_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) ++ ++#define SNDRV_EMU10K1_IOCTL_INFO _IOR ('H', 0x10, struct snd_emu10k1_fx8010_info) ++#define SNDRV_EMU10K1_IOCTL_CODE_POKE _IOW ('H', 0x11, struct snd_emu10k1_fx8010_code) ++#define SNDRV_EMU10K1_IOCTL_CODE_PEEK _IOWR('H', 0x12, struct snd_emu10k1_fx8010_code) ++#define SNDRV_EMU10K1_IOCTL_TRAM_SETUP _IOW ('H', 0x20, int) ++#define SNDRV_EMU10K1_IOCTL_TRAM_POKE _IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram) ++#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK _IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram) ++#define SNDRV_EMU10K1_IOCTL_PCM_POKE _IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec) ++#define SNDRV_EMU10K1_IOCTL_PCM_PEEK _IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec) ++#define SNDRV_EMU10K1_IOCTL_PVERSION _IOR ('H', 0x40, int) ++#define SNDRV_EMU10K1_IOCTL_STOP _IO ('H', 0x80) ++#define SNDRV_EMU10K1_IOCTL_CONTINUE _IO ('H', 0x81) ++#define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82) ++#define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int) ++#define SNDRV_EMU10K1_IOCTL_DBG_READ _IOR ('H', 0x84, int) ++ ++#ifndef __KERNEL__ ++/* typedefs for compatibility to user-space */ ++typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t; ++typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t; ++typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t; ++typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t; ++typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t; ++typedef struct emu10k1_ctl_elem_id emu10k1_ctl_elem_id_t; ++#endif ++ ++#endif /* _UAPI__SOUND_EMU10K1_H */ +diff --git a/include/sound/uapi/hdsp.h b/include/sound/uapi/hdsp.h +new file mode 100644 +index 000000000000..88c92a3fb477 +--- /dev/null ++++ b/include/sound/uapi/hdsp.h +@@ -0,0 +1,109 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++#ifndef __SOUND_HDSP_H ++#define __SOUND_HDSP_H ++ ++/* ++ * Copyright (C) 2003 Thomas Charbonnel (thomas@undata.org) ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ */ ++ ++#define HDSP_MATRIX_MIXER_SIZE 2048 ++ ++enum HDSP_IO_Type { ++ Digiface, ++ Multiface, ++ H9652, ++ H9632, ++ RPM, ++ Undefined, ++}; ++ ++struct hdsp_peak_rms { ++ __u32 input_peaks[26]; ++ __u32 playback_peaks[26]; ++ __u32 output_peaks[28]; ++ __u64 input_rms[26]; ++ __u64 playback_rms[26]; ++ /* These are only used for H96xx cards */ ++ __u64 output_rms[26]; ++}; ++ ++#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms) ++ ++struct hdsp_config_info { ++ unsigned char pref_sync_ref; ++ unsigned char wordclock_sync_check; ++ unsigned char spdif_sync_check; ++ unsigned char adatsync_sync_check; ++ unsigned char adat_sync_check[3]; ++ unsigned char spdif_in; ++ unsigned char spdif_out; ++ unsigned char spdif_professional; ++ unsigned char spdif_emphasis; ++ unsigned char spdif_nonaudio; ++ unsigned int spdif_sample_rate; ++ unsigned int system_sample_rate; ++ unsigned int autosync_sample_rate; ++ unsigned char system_clock_mode; ++ unsigned char clock_source; ++ unsigned char autosync_ref; ++ unsigned char line_out; ++ unsigned char passthru; ++ unsigned char da_gain; ++ unsigned char ad_gain; ++ unsigned char phone_gain; ++ unsigned char xlr_breakout_cable; ++ unsigned char analog_extension_board; ++}; ++ ++#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info) ++ ++struct hdsp_firmware { ++ void *firmware_data; /* 24413 x 4 bytes */ ++}; ++ ++#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware) ++ ++struct hdsp_version { ++ enum HDSP_IO_Type io_type; ++ unsigned short firmware_rev; ++}; ++ ++#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version) ++ ++struct hdsp_mixer { ++ unsigned short matrix[HDSP_MATRIX_MIXER_SIZE]; ++}; ++ ++#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer) ++ ++struct hdsp_9632_aeb { ++ int aebi; ++ int aebo; ++}; ++ ++#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb) ++ ++/* typedefs for compatibility to user-space */ ++typedef enum HDSP_IO_Type HDSP_IO_Type; ++typedef struct hdsp_peak_rms hdsp_peak_rms_t; ++typedef struct hdsp_config_info hdsp_config_info_t; ++typedef struct hdsp_firmware hdsp_firmware_t; ++typedef struct hdsp_version hdsp_version_t; ++typedef struct hdsp_mixer hdsp_mixer_t; ++typedef struct hdsp_9632_aeb hdsp_9632_aeb_t; ++ ++#endif /* __SOUND_HDSP_H */ +diff --git a/include/sound/uapi/hdspm.h b/include/sound/uapi/hdspm.h +new file mode 100644 +index 000000000000..2d91f90eb5e1 +--- /dev/null ++++ b/include/sound/uapi/hdspm.h +@@ -0,0 +1,230 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++#ifndef __SOUND_HDSPM_H ++#define __SOUND_HDSPM_H ++/* ++ * Copyright (C) 2003 Winfried Ritsch (IEM) ++ * based on hdsp.h from Thomas Charbonnel (thomas@undata.org) ++ * ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ++ */ ++ ++/* Maximum channels is 64 even on 56Mode you have 64playbacks to matrix */ ++#define HDSPM_MAX_CHANNELS 64 ++ ++enum hdspm_io_type { ++ MADI, ++ MADIface, ++ AIO, ++ AES32, ++ RayDAT ++}; ++ ++enum hdspm_speed { ++ ss, ++ ds, ++ qs ++}; ++ ++/* -------------------- IOCTL Peak/RMS Meters -------------------- */ ++ ++struct hdspm_peak_rms { ++ __u32 input_peaks[64]; ++ __u32 playback_peaks[64]; ++ __u32 output_peaks[64]; ++ ++ __u64 input_rms[64]; ++ __u64 playback_rms[64]; ++ __u64 output_rms[64]; ++ ++ __u8 speed; /* enum {ss, ds, qs} */ ++ int status2; ++}; ++ ++#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS \ ++ _IOR('H', 0x42, struct hdspm_peak_rms) ++ ++/* ------------ CONFIG block IOCTL ---------------------- */ ++ ++struct hdspm_config { ++ unsigned char pref_sync_ref; ++ unsigned char wordclock_sync_check; ++ unsigned char madi_sync_check; ++ unsigned int system_sample_rate; ++ unsigned int autosync_sample_rate; ++ unsigned char system_clock_mode; ++ unsigned char clock_source; ++ unsigned char autosync_ref; ++ unsigned char line_out; ++ unsigned int passthru; ++ unsigned int analog_out; ++}; ++ ++#define SNDRV_HDSPM_IOCTL_GET_CONFIG \ ++ _IOR('H', 0x41, struct hdspm_config) ++ ++/* ++ * If there's a TCO (TimeCode Option) board installed, ++ * there are further options and status data available. ++ * The hdspm_ltc structure contains the current SMPTE ++ * timecode and some status information and can be ++ * obtained via SNDRV_HDSPM_IOCTL_GET_LTC or in the ++ * hdspm_status struct. ++ */ ++ ++enum hdspm_ltc_format { ++ format_invalid, ++ fps_24, ++ fps_25, ++ fps_2997, ++ fps_30 ++}; ++ ++enum hdspm_ltc_frame { ++ frame_invalid, ++ drop_frame, ++ full_frame ++}; ++ ++enum hdspm_ltc_input_format { ++ ntsc, ++ pal, ++ no_video ++}; ++ ++struct hdspm_ltc { ++ unsigned int ltc; ++ ++ enum hdspm_ltc_format format; ++ enum hdspm_ltc_frame frame; ++ enum hdspm_ltc_input_format input_format; ++}; ++ ++#define SNDRV_HDSPM_IOCTL_GET_LTC _IOR('H', 0x46, struct hdspm_ltc) ++ ++/* ++ * The status data reflects the device's current state ++ * as determined by the card's configuration and ++ * connection status. ++ */ ++ ++enum hdspm_sync { ++ hdspm_sync_no_lock = 0, ++ hdspm_sync_lock = 1, ++ hdspm_sync_sync = 2 ++}; ++ ++enum hdspm_madi_input { ++ hdspm_input_optical = 0, ++ hdspm_input_coax = 1 ++}; ++ ++enum hdspm_madi_channel_format { ++ hdspm_format_ch_64 = 0, ++ hdspm_format_ch_56 = 1 ++}; ++ ++enum hdspm_madi_frame_format { ++ hdspm_frame_48 = 0, ++ hdspm_frame_96 = 1 ++}; ++ ++enum hdspm_syncsource { ++ syncsource_wc = 0, ++ syncsource_madi = 1, ++ syncsource_tco = 2, ++ syncsource_sync = 3, ++ syncsource_none = 4 ++}; ++ ++struct hdspm_status { ++ __u8 card_type; /* enum hdspm_io_type */ ++ enum hdspm_syncsource autosync_source; ++ ++ __u64 card_clock; ++ __u32 master_period; ++ ++ union { ++ struct { ++ __u8 sync_wc; /* enum hdspm_sync */ ++ __u8 sync_madi; /* enum hdspm_sync */ ++ __u8 sync_tco; /* enum hdspm_sync */ ++ __u8 sync_in; /* enum hdspm_sync */ ++ __u8 madi_input; /* enum hdspm_madi_input */ ++ __u8 channel_format; /* enum hdspm_madi_channel_format */ ++ __u8 frame_format; /* enum hdspm_madi_frame_format */ ++ } madi; ++ } card_specific; ++}; ++ ++#define SNDRV_HDSPM_IOCTL_GET_STATUS \ ++ _IOR('H', 0x47, struct hdspm_status) ++ ++/* ++ * Get information about the card and its add-ons. ++ */ ++ ++#define HDSPM_ADDON_TCO 1 ++ ++struct hdspm_version { ++ __u8 card_type; /* enum hdspm_io_type */ ++ char cardname[20]; ++ unsigned int serial; ++ unsigned short firmware_rev; ++ int addons; ++}; ++ ++#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x48, struct hdspm_version) ++ ++/* ------------- get Matrix Mixer IOCTL --------------- */ ++ ++/* MADI mixer: 64inputs+64playback in 64outputs = 8192 => *4Byte = ++ * 32768 Bytes ++ */ ++ ++/* organisation is 64 channelfader in a continuous memory block */ ++/* equivalent to hardware definition, maybe for future feature of mmap of ++ * them ++ */ ++/* each of 64 outputs has 64 infader and 64 outfader: ++ Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] */ ++ ++#define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS ++ ++struct hdspm_channelfader { ++ unsigned int in[HDSPM_MIXER_CHANNELS]; ++ unsigned int pb[HDSPM_MIXER_CHANNELS]; ++}; ++ ++struct hdspm_mixer { ++ struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS]; ++}; ++ ++struct hdspm_mixer_ioctl { ++ struct hdspm_mixer *mixer; ++}; ++ ++/* use indirect access due to the limit of ioctl bit size */ ++#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl) ++ ++/* typedefs for compatibility to user-space */ ++typedef struct hdspm_peak_rms hdspm_peak_rms_t; ++typedef struct hdspm_config_info hdspm_config_info_t; ++typedef struct hdspm_version hdspm_version_t; ++typedef struct hdspm_channelfader snd_hdspm_channelfader_t; ++typedef struct hdspm_mixer hdspm_mixer_t; ++ ++ ++#endif +diff --git a/include/sound/uapi/sb16_csp.h b/include/sound/uapi/sb16_csp.h +new file mode 100644 +index 000000000000..e64851481d88 +--- /dev/null ++++ b/include/sound/uapi/sb16_csp.h +@@ -0,0 +1,123 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++/* ++ * Copyright (c) 1999 by Uros Bizjak ++ * Takashi Iwai ++ * ++ * SB16ASP/AWE32 CSP control ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ */ ++#ifndef _UAPI__SOUND_SB16_CSP_H ++#define _UAPI__SOUND_SB16_CSP_H ++ ++ ++/* CSP modes */ ++#define SNDRV_SB_CSP_MODE_NONE 0x00 ++#define SNDRV_SB_CSP_MODE_DSP_READ 0x01 /* Record from DSP */ ++#define SNDRV_SB_CSP_MODE_DSP_WRITE 0x02 /* Play to DSP */ ++#define SNDRV_SB_CSP_MODE_QSOUND 0x04 /* QSound */ ++ ++/* CSP load flags */ ++#define SNDRV_SB_CSP_LOAD_FROMUSER 0x01 ++#define SNDRV_SB_CSP_LOAD_INITBLOCK 0x02 ++ ++/* CSP sample width */ ++#define SNDRV_SB_CSP_SAMPLE_8BIT 0x01 ++#define SNDRV_SB_CSP_SAMPLE_16BIT 0x02 ++ ++/* CSP channels */ ++#define SNDRV_SB_CSP_MONO 0x01 ++#define SNDRV_SB_CSP_STEREO 0x02 ++ ++/* CSP rates */ ++#define SNDRV_SB_CSP_RATE_8000 0x01 ++#define SNDRV_SB_CSP_RATE_11025 0x02 ++#define SNDRV_SB_CSP_RATE_22050 0x04 ++#define SNDRV_SB_CSP_RATE_44100 0x08 ++#define SNDRV_SB_CSP_RATE_ALL 0x0f ++ ++/* CSP running state */ ++#define SNDRV_SB_CSP_ST_IDLE 0x00 ++#define SNDRV_SB_CSP_ST_LOADED 0x01 ++#define SNDRV_SB_CSP_ST_RUNNING 0x02 ++#define SNDRV_SB_CSP_ST_PAUSED 0x04 ++#define SNDRV_SB_CSP_ST_AUTO 0x08 ++#define SNDRV_SB_CSP_ST_QSOUND 0x10 ++ ++/* maximum QSound value (180 degrees right) */ ++#define SNDRV_SB_CSP_QSOUND_MAX_RIGHT 0x20 ++ ++/* maximum microcode RIFF file size */ ++#define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE 0x3000 ++ ++/* microcode header */ ++struct snd_sb_csp_mc_header { ++ char codec_name[16]; /* id name of codec */ ++ unsigned short func_req; /* requested function */ ++}; ++ ++/* microcode to be loaded */ ++struct snd_sb_csp_microcode { ++ struct snd_sb_csp_mc_header info; ++ unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE]; ++}; ++ ++/* start CSP with sample_width in mono/stereo */ ++struct snd_sb_csp_start { ++ int sample_width; /* sample width, look above */ ++ int channels; /* channels, look above */ ++}; ++ ++/* CSP information */ ++struct snd_sb_csp_info { ++ char codec_name[16]; /* id name of codec */ ++ unsigned short func_nr; /* function number */ ++ unsigned int acc_format; /* accepted PCM formats */ ++ unsigned short acc_channels; /* accepted channels */ ++ unsigned short acc_width; /* accepted sample width */ ++ unsigned short acc_rates; /* accepted sample rates */ ++ unsigned short csp_mode; /* CSP mode, see above */ ++ unsigned short run_channels; /* current channels */ ++ unsigned short run_width; /* current sample width */ ++ unsigned short version; /* version id: 0x10 - 0x1f */ ++ unsigned short state; /* state bits */ ++}; ++ ++/* HWDEP controls */ ++/* get CSP information */ ++#define SNDRV_SB_CSP_IOCTL_INFO _IOR('H', 0x10, struct snd_sb_csp_info) ++/* load microcode to CSP */ ++/* NOTE: struct snd_sb_csp_microcode overflows the max size (13 bits) ++ * defined for some architectures like MIPS, and it leads to build errors. ++ * (x86 and co have 14-bit size, thus it's valid, though.) ++ * As a workaround for skipping the size-limit check, here we don't use the ++ * normal _IOW() macro but _IOC() with the manual argument. ++ */ ++#define SNDRV_SB_CSP_IOCTL_LOAD_CODE \ ++ _IOC(_IOC_WRITE, 'H', 0x11, sizeof(struct snd_sb_csp_microcode)) ++/* unload microcode from CSP */ ++#define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE _IO('H', 0x12) ++/* start CSP */ ++#define SNDRV_SB_CSP_IOCTL_START _IOW('H', 0x13, struct snd_sb_csp_start) ++/* stop CSP */ ++#define SNDRV_SB_CSP_IOCTL_STOP _IO('H', 0x14) ++/* pause CSP and DMA transfer */ ++#define SNDRV_SB_CSP_IOCTL_PAUSE _IO('H', 0x15) ++/* restart CSP and DMA transfer */ ++#define SNDRV_SB_CSP_IOCTL_RESTART _IO('H', 0x16) ++ ++ ++#endif /* _UAPI__SOUND_SB16_CSP_H */ +diff --git a/include/sound/uapi/sscape_ioctl.h b/include/sound/uapi/sscape_ioctl.h +new file mode 100644 +index 000000000000..c6653ebfb2c4 +--- /dev/null ++++ b/include/sound/uapi/sscape_ioctl.h +@@ -0,0 +1,21 @@ ++#ifndef SSCAPE_IOCTL_H ++#define SSCAPE_IOCTL_H ++ ++ ++struct sscape_bootblock ++{ ++ unsigned char code[256]; ++ unsigned version; ++}; ++ ++#define SSCAPE_MICROCODE_SIZE 65536 ++ ++struct sscape_microcode ++{ ++ unsigned char *code; ++}; ++ ++#define SND_SSCAPE_LOAD_BOOTB _IOWR('P', 100, struct sscape_bootblock) ++#define SND_SSCAPE_LOAD_MCODE _IOW ('P', 101, struct sscape_microcode) ++ ++#endif +diff --git a/include/sound/uapi/tlv.h b/include/sound/uapi/tlv.h +new file mode 100644 +index 000000000000..7d6d65f60a42 +--- /dev/null ++++ b/include/sound/uapi/tlv.h +@@ -0,0 +1,117 @@ ++/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++ ++#ifndef __UAPI_SOUND_TLV_H ++#define __UAPI_SOUND_TLV_H ++ ++#define SNDRV_CTL_TLVT_CONTAINER 0 /* one level down - group of TLVs */ ++#define SNDRV_CTL_TLVT_DB_SCALE 1 /* dB scale */ ++#define SNDRV_CTL_TLVT_DB_LINEAR 2 /* linear volume */ ++#define SNDRV_CTL_TLVT_DB_RANGE 3 /* dB range container */ ++#define SNDRV_CTL_TLVT_DB_MINMAX 4 /* dB scale with min/max */ ++#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 /* dB scale with min/max with mute */ ++ ++/* ++ * channel-mapping TLV items ++ * TLV length must match with num_channels ++ */ ++#define SNDRV_CTL_TLVT_CHMAP_FIXED 0x101 /* fixed channel position */ ++#define SNDRV_CTL_TLVT_CHMAP_VAR 0x102 /* channels freely swappable */ ++#define SNDRV_CTL_TLVT_CHMAP_PAIRED 0x103 /* pair-wise swappable */ ++ ++/* ++ * TLV structure is right behind the struct snd_ctl_tlv: ++ * unsigned int type - see SNDRV_CTL_TLVT_* ++ * unsigned int length ++ * .... data aligned to sizeof(unsigned int), use ++ * block_length = (length + (sizeof(unsigned int) - 1)) & ++ * ~(sizeof(unsigned int) - 1)) .... ++ */ ++#define SNDRV_CTL_TLVD_ITEM(type, ...) \ ++ (type), SNDRV_CTL_TLVD_LENGTH(__VA_ARGS__), __VA_ARGS__ ++#define SNDRV_CTL_TLVD_LENGTH(...) \ ++ ((unsigned int)sizeof((const unsigned int[]) { __VA_ARGS__ })) ++ ++/* Accessor offsets for TLV data items */ ++#define SNDRV_CTL_TLVO_TYPE 0 ++#define SNDRV_CTL_TLVO_LEN 1 ++ ++#define SNDRV_CTL_TLVD_CONTAINER_ITEM(...) \ ++ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_CONTAINER, __VA_ARGS__) ++#define SNDRV_CTL_TLVD_DECLARE_CONTAINER(name, ...) \ ++ unsigned int name[] = { \ ++ SNDRV_CTL_TLVD_CONTAINER_ITEM(__VA_ARGS__) \ ++ } ++ ++#define SNDRV_CTL_TLVD_DB_SCALE_MASK 0xffff ++#define SNDRV_CTL_TLVD_DB_SCALE_MUTE 0x10000 ++#define SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ ++ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_SCALE, \ ++ (min), \ ++ ((step) & SNDRV_CTL_TLVD_DB_SCALE_MASK) | \ ++ ((mute) ? SNDRV_CTL_TLVD_DB_SCALE_MUTE : 0)) ++#define SNDRV_CTL_TLVD_DECLARE_DB_SCALE(name, min, step, mute) \ ++ unsigned int name[] = { \ ++ SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ ++ } ++ ++/* Accessor offsets for min, mute and step items in dB scale type TLV */ ++#define SNDRV_CTL_TLVO_DB_SCALE_MIN 2 ++#define SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP 3 ++ ++/* dB scale specified with min/max values instead of step */ ++#define SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ ++ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX, (min_dB), (max_dB)) ++#define SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ ++ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX_MUTE, (min_dB), (max_dB)) ++#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(name, min_dB, max_dB) \ ++ unsigned int name[] = { \ ++ SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ ++ } ++#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE(name, min_dB, max_dB) \ ++ unsigned int name[] = { \ ++ SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ ++ } ++ ++/* Accessor offsets for min, max items in db-minmax types of TLV. */ ++#define SNDRV_CTL_TLVO_DB_MINMAX_MIN 2 ++#define SNDRV_CTL_TLVO_DB_MINMAX_MAX 3 ++ ++/* linear volume between min_dB and max_dB (.01dB unit) */ ++#define SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ ++ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_LINEAR, (min_dB), (max_dB)) ++#define SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(name, min_dB, max_dB) \ ++ unsigned int name[] = { \ ++ SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ ++ } ++ ++/* Accessor offsets for min, max items in db-linear type of TLV. */ ++#define SNDRV_CTL_TLVO_DB_LINEAR_MIN 2 ++#define SNDRV_CTL_TLVO_DB_LINEAR_MAX 3 ++ ++/* dB range container: ++ * Items in dB range container must be ordered by their values and by their ++ * dB values. This implies that larger values must correspond with larger ++ * dB values (which is also required for all other mixer controls). ++ */ ++/* Each item is: */ ++#define SNDRV_CTL_TLVD_DB_RANGE_ITEM(...) \ ++ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_RANGE, __VA_ARGS__) ++#define SNDRV_CTL_TLVD_DECLARE_DB_RANGE(name, ...) \ ++ unsigned int name[] = { \ ++ SNDRV_CTL_TLVD_DB_RANGE_ITEM(__VA_ARGS__) \ ++ } ++ ++#define SNDRV_CTL_TLVD_DB_GAIN_MUTE -9999999 ++ ++#endif +diff --git a/src/topology/tplg_local.h b/src/topology/tplg_local.h +index 11efce6d580c..101491a42e60 100644 +--- a/src/topology/tplg_local.h ++++ b/src/topology/tplg_local.h +@@ -18,8 +18,7 @@ + #include "list.h" + #include "topology.h" + +-#define __packed __attribute__((__packed__)) +- ++#include + #include + #include + #include +-- +2.16.4 + diff --git a/0030-type_compat-Add-missing-__s64-and-__u64-definitions-.patch b/0030-type_compat-Add-missing-__s64-and-__u64-definitions-.patch new file mode 100644 index 0000000..e55308d --- /dev/null +++ b/0030-type_compat-Add-missing-__s64-and-__u64-definitions-.patch @@ -0,0 +1,32 @@ +From 75584fe660880b332fbf60dd7968e2ed8b49a38b Mon Sep 17 00:00:00 2001 +From: Takashi Iwai +Date: Fri, 20 Dec 2019 16:12:50 +0100 +Subject: [PATCH 30/30] type_compat: Add missing __s64 and __u64 definitions + for non-Linux + +Just for the case without Linux-compatible definitions. + +Signed-off-by: Takashi Iwai +--- + include/sound/type_compat.h | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/include/sound/type_compat.h b/include/sound/type_compat.h +index d4790c1f0e64..5b765f447e2e 100644 +--- a/include/sound/type_compat.h ++++ b/include/sound/type_compat.h +@@ -9,9 +9,11 @@ + typedef uint8_t __u8; + typedef uint16_t __u16; + typedef uint32_t __u32; ++typedef uint64_t __u64; + typedef int8_t __s8; + typedef int16_t __s16; + typedef int32_t __s32; ++typedef int64_t __s64; + + #include + #include +-- +2.16.4 + diff --git a/0031-uapi-Move-typedefs-from-uapi-to-sound.patch b/0031-uapi-Move-typedefs-from-uapi-to-sound.patch new file mode 100644 index 0000000..ebe559d --- /dev/null +++ b/0031-uapi-Move-typedefs-from-uapi-to-sound.patch @@ -0,0 +1,133 @@ +From 59792f467b38d6a4c4dffdb30528f7fb03d23d96 Mon Sep 17 00:00:00 2001 +From: Takashi Iwai +Date: Fri, 20 Dec 2019 17:12:37 +0100 +Subject: [PATCH alsa-lib] uapi: Move typedefs from uapi to sound/* + +For keeping uapi/*.h cleaner. + +Signed-off-by: Takashi Iwai +--- + include/sound/emu10k1.h | 9 +++++++++ + include/sound/hdsp.h | 10 ++++++++++ + include/sound/hdspm.h | 8 ++++++++ + include/sound/sb16_csp.h | 4 ++++ + include/sound/uapi/emu10k1.h | 10 ---------- + include/sound/uapi/hdsp.h | 9 --------- + include/sound/uapi/hdspm.h | 8 -------- + 7 files changed, 31 insertions(+), 27 deletions(-) + +diff --git a/include/sound/emu10k1.h b/include/sound/emu10k1.h +index f06ecee51c2b..0832f95bd995 100644 +--- a/include/sound/emu10k1.h ++++ b/include/sound/emu10k1.h +@@ -1,2 +1,11 @@ + #include + #include ++#ifndef __emu10k1_type_defined ++#define __emu10k1_type_defined ++typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t; ++typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t; ++typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t; ++typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t; ++typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t; ++typedef struct emu10k1_ctl_elem_id emu10k1_ctl_elem_id_t; ++#endif +diff --git a/include/sound/hdsp.h b/include/sound/hdsp.h +index 78fb745b607a..e8f931569548 100644 +--- a/include/sound/hdsp.h ++++ b/include/sound/hdsp.h +@@ -1,2 +1,12 @@ + #include + #include ++#ifndef __hdsp_type_defined ++#define __hdsp_type_defined ++typedef enum HDSP_IO_Type HDSP_IO_Type; ++typedef struct hdsp_peak_rms hdsp_peak_rms_t; ++typedef struct hdsp_config_info hdsp_config_info_t; ++typedef struct hdsp_firmware hdsp_firmware_t; ++typedef struct hdsp_version hdsp_version_t; ++typedef struct hdsp_mixer hdsp_mixer_t; ++typedef struct hdsp_9632_aeb hdsp_9632_aeb_t; ++#endif +diff --git a/include/sound/hdspm.h b/include/sound/hdspm.h +index af6d19eda87f..d9095d9f10bb 100644 +--- a/include/sound/hdspm.h ++++ b/include/sound/hdspm.h +@@ -1,2 +1,10 @@ + #include + #include ++#ifndef __hdspm_type_defined ++#define __hdspm_type_defined ++typedef struct hdspm_peak_rms hdspm_peak_rms_t; ++typedef struct hdspm_config_info hdspm_config_info_t; ++typedef struct hdspm_version hdspm_version_t; ++typedef struct hdspm_channelfader snd_hdspm_channelfader_t; ++typedef struct hdspm_mixer hdspm_mixer_t; ++#endif +diff --git a/include/sound/sb16_csp.h b/include/sound/sb16_csp.h +index 24121fcbd888..fd02bc565e21 100644 +--- a/include/sound/sb16_csp.h ++++ b/include/sound/sb16_csp.h +@@ -1 +1,5 @@ + #include ++#ifndef __sb16_csp_type_defined ++#define __sb16_csp_type_defined ++typedef struct snd_sb_csp_microcode snd_sb_csp_microcode_t; ++#endif +diff --git a/include/sound/uapi/emu10k1.h b/include/sound/uapi/emu10k1.h +index c1150e4d0231..6bcd76f64c1c 100644 +--- a/include/sound/uapi/emu10k1.h ++++ b/include/sound/uapi/emu10k1.h +@@ -382,14 +382,4 @@ struct snd_emu10k1_fx8010_pcm_rec { + #define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int) + #define SNDRV_EMU10K1_IOCTL_DBG_READ _IOR ('H', 0x84, int) + +-#ifndef __KERNEL__ +-/* typedefs for compatibility to user-space */ +-typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t; +-typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t; +-typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t; +-typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t; +-typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t; +-typedef struct emu10k1_ctl_elem_id emu10k1_ctl_elem_id_t; +-#endif +- + #endif /* _UAPI__SOUND_EMU10K1_H */ +diff --git a/include/sound/uapi/hdsp.h b/include/sound/uapi/hdsp.h +index 88c92a3fb477..7ac2d3f2a9b3 100644 +--- a/include/sound/uapi/hdsp.h ++++ b/include/sound/uapi/hdsp.h +@@ -97,13 +97,4 @@ struct hdsp_9632_aeb { + + #define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb) + +-/* typedefs for compatibility to user-space */ +-typedef enum HDSP_IO_Type HDSP_IO_Type; +-typedef struct hdsp_peak_rms hdsp_peak_rms_t; +-typedef struct hdsp_config_info hdsp_config_info_t; +-typedef struct hdsp_firmware hdsp_firmware_t; +-typedef struct hdsp_version hdsp_version_t; +-typedef struct hdsp_mixer hdsp_mixer_t; +-typedef struct hdsp_9632_aeb hdsp_9632_aeb_t; +- + #endif /* __SOUND_HDSP_H */ +diff --git a/include/sound/uapi/hdspm.h b/include/sound/uapi/hdspm.h +index 2d91f90eb5e1..3fbfd9dc5f51 100644 +--- a/include/sound/uapi/hdspm.h ++++ b/include/sound/uapi/hdspm.h +@@ -219,12 +219,4 @@ struct hdspm_mixer_ioctl { + /* use indirect access due to the limit of ioctl bit size */ + #define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl) + +-/* typedefs for compatibility to user-space */ +-typedef struct hdspm_peak_rms hdspm_peak_rms_t; +-typedef struct hdspm_config_info hdspm_config_info_t; +-typedef struct hdspm_version hdspm_version_t; +-typedef struct hdspm_channelfader snd_hdspm_channelfader_t; +-typedef struct hdspm_mixer hdspm_mixer_t; +- +- + #endif +-- +2.16.4 + diff --git a/alsa-lib-1.2.1.1.tar.bz2 b/alsa-lib-1.2.1.1.tar.bz2 deleted file mode 120000 index a6e8f27..0000000 --- a/alsa-lib-1.2.1.1.tar.bz2 +++ /dev/null @@ -1 +0,0 @@ -/ipfs/bafybeicvihkgz3axtzf62fj234i2kvmfgs7za4ywe3yz5zzjfvecr3pmve \ No newline at end of file diff --git a/alsa-lib-1.2.1.2.tar.bz2 b/alsa-lib-1.2.1.2.tar.bz2 new file mode 120000 index 0000000..f81d831 --- /dev/null +++ b/alsa-lib-1.2.1.2.tar.bz2 @@ -0,0 +1 @@ +/ipfs/bafybeihmqw6re4nrq75tiezvbqfj2egqmats2xvascmztvlqv7qqdqp5ca \ No newline at end of file diff --git a/alsa.changes b/alsa.changes index 93e20fc..7628da3 100644 --- a/alsa.changes +++ b/alsa.changes @@ -1,4 +1,49 @@ ------------------------------------------------------------------- +Fri Dec 20 16:54:25 CET 2019 - tiwai@suse.de + +- Upstream fixes, including the alsa-tools build breakage: + 0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch + 0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch + 0003-ucm-add-_identifiers-list.patch + 0004-namehint-correct-the-args-check.patch + 0005-namehint-improve-the-previous-patch-check-the-return.patch + 0006-ucm-docs-allow-spaces-in-device-names-for-JackHWMute.patch + 0007-use-case-docs-add-PlaybackMixerCopy-and-CaptureMixer.patch + 0008-ucm-docs-add-JackCTL-rearrange-JackControl-and-JackD.patch + 0009-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch + 0010-src-ucm-main.c-fix-build-without-mixer.patch + 0011-alsa.m4-another-try-to-fix-the-libatopology-detectio.patch + 0012-ucm-docs-add-Mic-DigitalMic-and-multiple-devices-com.patch + 0013-ucm-docs-remove-DigitalMic-it-does-not-have-sense.patch + 0014-ucm-docs-change-the-Mic-description-to-simple-Microp.patch + 0015-ucm-docs-add-note-about-the-sequences-and-device-spl.patch + 0016-ucm-docs-remove-MixerCopy-values-add-Priority-for-ve.patch + 0017-ucm-setup-conf_format-after-getting-ALSA_CONFIG_UCM_.patch + 0018-alsa-lib-fix-the-array-parser-unique-compound-keys.patch + 0019-topology-remove-vendor_fd-name-from-snd_tplg-structu.patch + 0020-topology-file-position-and-size-cleanups.patch + 0021-topology-use-an-array-describing-blocks-for-the-main.patch + 0022-topology-use-size_t-for-calc_block_size.patch + 0023-topology-merge-write_block-to-tplg_write_data.patch + 0024-topology-make-vebose-output-more-nice.patch + 0025-topology-use-list_insert-macro-in-tplg_elem_insert.patch + 0026-topology-dapm-coding-fixes.patch + 0027-topology-dapm-merge-identical-index-blocks-like-for-.patch + 0028-topology-more-coding-fixes.patch + 0029-Fix-alsa-sound-.h-for-external-programs.patch + 0030-type_compat-Add-missing-__s64-and-__u64-definitions-.patch + 0031-uapi-Move-typedefs-from-uapi-to-sound.patch + +------------------------------------------------------------------- +Fri Nov 29 20:41:29 CET 2019 - tiwai@suse.de + +- Update to alsa-lib 1.2.1.2: + More UCM and UCMv2 fixes / enhancements, details are found in + https://www.alsa-project.org/wiki/Changes_v1.2.1.1_v1.2.1.2 +- Obsoleted patch: + 0001-alsa.m4-Fix-the-detection-of-topology-library-availa.patch + +------------------------------------------------------------------- Wed Nov 27 10:21:23 CET 2019 - tiwai@suse.de - Fix the detection of topology library in alsa.m4: diff --git a/alsa.spec b/alsa.spec index 1d053d1..d26a8d8 100644 --- a/alsa.spec +++ b/alsa.spec @@ -26,7 +26,7 @@ %endif Name: alsa -Version: 1.2.1.1 +Version: 1.2.1.2 Release: 0 Summary: Advanced Linux Sound Architecture License: LGPL-2.1-or-later @@ -48,7 +48,37 @@ Source31: all_notes_off.bin Source32: all_notes_off.mid Source34: alsa-init.sh # upstream fixes -Patch1: 0001-alsa.m4-Fix-the-detection-of-topology-library-availa.patch +Patch1: 0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch +Patch2: 0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch +Patch3: 0003-ucm-add-_identifiers-list.patch +Patch4: 0004-namehint-correct-the-args-check.patch +Patch5: 0005-namehint-improve-the-previous-patch-check-the-return.patch +Patch6: 0006-ucm-docs-allow-spaces-in-device-names-for-JackHWMute.patch +Patch7: 0007-use-case-docs-add-PlaybackMixerCopy-and-CaptureMixer.patch +Patch8: 0008-ucm-docs-add-JackCTL-rearrange-JackControl-and-JackD.patch +Patch9: 0009-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch +Patch10: 0010-src-ucm-main.c-fix-build-without-mixer.patch +Patch11: 0011-alsa.m4-another-try-to-fix-the-libatopology-detectio.patch +Patch12: 0012-ucm-docs-add-Mic-DigitalMic-and-multiple-devices-com.patch +Patch13: 0013-ucm-docs-remove-DigitalMic-it-does-not-have-sense.patch +Patch14: 0014-ucm-docs-change-the-Mic-description-to-simple-Microp.patch +Patch15: 0015-ucm-docs-add-note-about-the-sequences-and-device-spl.patch +Patch16: 0016-ucm-docs-remove-MixerCopy-values-add-Priority-for-ve.patch +Patch17: 0017-ucm-setup-conf_format-after-getting-ALSA_CONFIG_UCM_.patch +Patch18: 0018-alsa-lib-fix-the-array-parser-unique-compound-keys.patch +Patch19: 0019-topology-remove-vendor_fd-name-from-snd_tplg-structu.patch +Patch20: 0020-topology-file-position-and-size-cleanups.patch +Patch21: 0021-topology-use-an-array-describing-blocks-for-the-main.patch +Patch22: 0022-topology-use-size_t-for-calc_block_size.patch +Patch23: 0023-topology-merge-write_block-to-tplg_write_data.patch +Patch24: 0024-topology-make-vebose-output-more-nice.patch +Patch25: 0025-topology-use-list_insert-macro-in-tplg_elem_insert.patch +Patch26: 0026-topology-dapm-coding-fixes.patch +Patch27: 0027-topology-dapm-merge-identical-index-blocks-like-for-.patch +Patch28: 0028-topology-more-coding-fixes.patch +Patch29: 0029-Fix-alsa-sound-.h-for-external-programs.patch +Patch30: 0030-type_compat-Add-missing-__s64-and-__u64-definitions-.patch +Patch31: 0031-uapi-Move-typedefs-from-uapi-to-sound.patch # rest suse fixes Patch101: alsa-lib-ignore-non-accessible-ALSA_CONFIG_PATH.patch BuildRequires: doxygen @@ -134,6 +164,36 @@ This package contains the library for ALSA topology support. %prep %setup -q -n alsa-lib-%{version} %patch1 -p1 +%patch2 -p1 +%patch3 -p1 +%patch4 -p1 +%patch5 -p1 +%patch6 -p1 +%patch7 -p1 +%patch8 -p1 +%patch9 -p1 +%patch10 -p1 +%patch11 -p1 +%patch12 -p1 +%patch13 -p1 +%patch14 -p1 +%patch15 -p1 +%patch16 -p1 +%patch17 -p1 +%patch18 -p1 +%patch19 -p1 +%patch20 -p1 +%patch21 -p1 +%patch22 -p1 +%patch23 -p1 +%patch24 -p1 +%patch25 -p1 +%patch26 -p1 +%patch27 -p1 +%patch28 -p1 +%patch29 -p1 +%patch30 -p1 +%patch31 -p1 %patch101 -p1 %build @@ -141,7 +201,7 @@ This package contains the library for ALSA topology support. %define _lto_cflags %{nil} export AUTOMAKE_JOBS="%{?_smp_mflags}" # build alsa-lib -# autoreconf -fi +autoreconf -fi %configure \ --disable-static \ --enable-symbolic-functions \