Changeset 750

Timestamp:

Oct 3, 2022, 4:24:46 AM (3 years ago)

Author:

Paul Smedley

Message:

Update linux core to the 6.0 kernel

Location:

GPL/branches/uniaud32-exp

Files:

• alsa-kernel/core/control.c (modified) (27 diffs)
• alsa-kernel/core/device.c (modified) (1 diff)
• alsa-kernel/core/info.c (modified) (1 diff)
• alsa-kernel/core/init.c (modified) (8 diffs)
• alsa-kernel/core/memalloc.c (modified) (1 diff)
• alsa-kernel/core/pcm.c (modified) (3 diffs)
• alsa-kernel/core/pcm_memory.c (modified) (2 diffs)
• alsa-kernel/core/pcm_native.c (modified) (3 diffs)
• alsa-kernel/core/rawmidi.c (modified) (51 diffs)
• alsa-kernel/core/vmaster.c (modified) (1 diff)
• alsa-kernel/hda/ext/hdac_ext_controller.c (modified) (1 diff)
• alsa-kernel/hda/hdac_bus.c (modified) (1 diff)
• alsa-kernel/hda/hdac_controller.c (modified) (1 diff)
• alsa-kernel/hda/trace.h (modified) (3 diffs)
• alsa-kernel/include/sound/config.h (modified) (1 diff)
• alsa-kernel/include/sound/control.h (modified) (1 diff)
• alsa-kernel/include/sound/core.h (modified) (2 diffs)
• alsa-kernel/include/sound/dmaengine_pcm.h (modified) (1 diff)
• alsa-kernel/include/sound/hda_codec.h (modified) (1 diff)
• alsa-kernel/include/sound/hdaudio.h (modified) (1 diff)
• alsa-kernel/include/sound/hdmi-codec.h (modified) (1 diff)
• alsa-kernel/include/sound/madera-pdata.h (modified) (1 diff)
• alsa-kernel/include/sound/pcm.h (modified) (26 diffs)
• alsa-kernel/include/sound/rawmidi.h (modified) (3 diffs)
• alsa-kernel/include/sound/simple_card_utils.h (modified) (4 diffs)
• alsa-kernel/include/sound/soc-acpi-intel-match.h (modified) (2 diffs)
• alsa-kernel/include/sound/soc-component.h (modified) (2 diffs)
• alsa-kernel/include/sound/soc-dai.h (modified) (1 diff)
• alsa-kernel/include/sound/soc.h (modified) (3 diffs)
• alsa-kernel/include/sound/sof.h (modified) (1 diff)
• alsa-kernel/include/sound/version.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/asound.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/compress_offload.h (modified) (1 diff)
• alsa-kernel/include/uapi/sound/compress_params.h (modified) (3 diffs)
• alsa-kernel/pci/emu10k1/memory.c (modified) (1 diff)
• alsa-kernel/pci/ens1370.c (modified) (1 diff)
• alsa-kernel/pci/hda/hda_bind.c (modified) (1 diff)
• alsa-kernel/pci/hda/hda_codec.c (modified) (9 diffs)
• alsa-kernel/pci/hda/hda_component2.h (modified) (1 diff)
• alsa-kernel/pci/hda/hda_sysfs.c (modified) (7 diffs)
• alsa-kernel/pci/hda/patch_hdmi.c (modified) (1 diff)
• alsa-kernel/pci/hda/patch_realtek.c (modified) (9 diffs)
• include/linux/pm.h (modified) (1 diff)
• include/linux/xarray.h (added)
• lib32/misc.c (modified) (2 diffs)
• lib32/vsprintf.c (modified) (2 diffs)

GPL/branches/uniaud32-exp/alsa-kernel/core/control.c

@@ -161 +161 @@
                 return;
         read_lock_irqsave(&card->ctl_files_rwlock, flags);
-#if IS_ENABLED(CONFIG_SND_MIXER_OSS)
+//#if (IS_ENABLED(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS))
+#if defined(CONFIG_SND_MIXER_OSS)
         card->mixer_oss_change_count++;
 #endif
@@ -378 +379 @@
 }
 
+/* check whether the given id is contained in the given kctl */
+static bool elem_id_matches(const struct snd_kcontrol *kctl,
+                            const struct snd_ctl_elem_id *id)
+{
+        return kctl->id.iface == id->iface &&
+                kctl->id.device == id->device &&
+                kctl->id.subdevice == id->subdevice &&
+                !strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)) &&
+                kctl->id.index <= id->index &&
+                kctl->id.index + kctl->count > id->index;
+}
+
+#ifdef CONFIG_SND_CTL_FAST_LOOKUP
+/* Compute a hash key for the corresponding ctl id
+ * It's for the name lookup, hence the numid is excluded.
+ * The hash key is bound in LONG_MAX to be used for Xarray key.
+ */
+#define MULTIPLIER      37
+static unsigned long get_ctl_id_hash(const struct snd_ctl_elem_id *id)
+{
+        int i;
+        unsigned long h;
+
+        h = id->iface;
+        h = MULTIPLIER * h + id->device;
+        h = MULTIPLIER * h + id->subdevice;
+        for (i = 0; i < SNDRV_CTL_ELEM_ID_NAME_MAXLEN && id->name[i]; i++)
+                h = MULTIPLIER * h + id->name[i];
+        h = MULTIPLIER * h + id->index;
+        h &= LONG_MAX;
+        return h;
+}
+
+/* add hash entries to numid and ctl xarray tables */
+static void add_hash_entries(struct snd_card *card,
+                             struct snd_kcontrol *kcontrol)
+{
+        struct snd_ctl_elem_id id = kcontrol->id;
+        int i;
+
+        xa_store_range(&card->ctl_numids, kcontrol->id.numid,
+                       kcontrol->id.numid + kcontrol->count - 1,
+                       kcontrol, GFP_KERNEL);
+
+        for (i = 0; i < kcontrol->count; i++) {
+                id.index = kcontrol->id.index + i;
+                if (xa_insert(&card->ctl_hash, get_ctl_id_hash(&id),
+                              kcontrol, GFP_KERNEL)) {
+                        /* skip hash for this entry, noting we had collision */
+                        card->ctl_hash_collision = true;
+                        dev_dbg(card->dev, "ctl_hash collision %d:%s:%d\n",
+                                id.iface, id.name, id.index);
+                }
+        }
+}
+
+/* remove hash entries that have been added */
+static void remove_hash_entries(struct snd_card *card,
+                                struct snd_kcontrol *kcontrol)
+{
+        struct snd_ctl_elem_id id = kcontrol->id;
+        struct snd_kcontrol *matched;
+        unsigned long h;
+        int i;
+
+        for (i = 0; i < kcontrol->count; i++) {
+                xa_erase(&card->ctl_numids, id.numid);
+                h = get_ctl_id_hash(&id);
+                matched = xa_load(&card->ctl_hash, h);
+                if (matched && (matched == kcontrol ||
+                                elem_id_matches(matched, &id)))
+                        xa_erase(&card->ctl_hash, h);
+                id.index++;
+                id.numid++;
+        }
+}
+#else /* CONFIG_SND_CTL_FAST_LOOKUP */
+static inline void add_hash_entries(struct snd_card *card,
+                                    struct snd_kcontrol *kcontrol)
+{
+}
+static inline void remove_hash_entries(struct snd_card *card,
+                                       struct snd_kcontrol *kcontrol)
+{
+}
+#endif /* CONFIG_SND_CTL_FAST_LOOKUP */
+
 enum snd_ctl_add_mode {
         CTL_ADD_EXCLUSIVE, CTL_REPLACE, CTL_ADD_ON_REPLACE,
@@ -422 +510 @@
         card->last_numid += kcontrol->count;
 
+        add_hash_entries(card, kcontrol);
+
         for (idx = 0; idx < kcontrol->count; idx++)
                 snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_ADD, kcontrol, idx);
@@ -493 +583 @@
 EXPORT_SYMBOL(snd_ctl_replace);
 
+static int __snd_ctl_remove(struct snd_card *card,
+                            struct snd_kcontrol *kcontrol,
+                            bool remove_hash)
+{
+        unsigned int idx;
+
+        if (snd_BUG_ON(!card || !kcontrol))
+                return -EINVAL;
+        list_del(&kcontrol->list);
+
+        if (remove_hash)
+                remove_hash_entries(card, kcontrol);
+
+        card->controls_count -= kcontrol->count;
+        for (idx = 0; idx < kcontrol->count; idx++)
+                snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_REMOVE, kcontrol, idx);
+        snd_ctl_free_one(kcontrol);
+        return 0;
+}
+
 /**
  * snd_ctl_remove - remove the control from the card and release it
@@ -506 +616 @@
 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 {
-        unsigned int idx;
-
-        if (snd_BUG_ON(!card || !kcontrol))
-                return -EINVAL;
-        list_del(&kcontrol->list);
-        card->controls_count -= kcontrol->count;
-        for (idx = 0; idx < kcontrol->count; idx++)
-                snd_ctl_notify_one(card, SNDRV_CTL_EVENT_MASK_REMOVE, kcontrol, idx);
-        snd_ctl_free_one(kcontrol);
-        return 0;
+        return __snd_ctl_remove(card, kcontrol, true);
 }
 EXPORT_SYMBOL(snd_ctl_remove);
@@ -656 +757 @@
                 return -ENOENT;
         }
+        remove_hash_entries(card, kctl);
         kctl->id = *dst_id;
         kctl->id.numid = card->last_numid + 1;
         card->last_numid += kctl->count;
+        add_hash_entries(card, kctl);
         up_write(&card->controls_rwsem);
         return 0;
 }
 EXPORT_SYMBOL(snd_ctl_rename_id);
+
+#ifndef CONFIG_SND_CTL_FAST_LOOKUP
+static struct snd_kcontrol *
+snd_ctl_find_numid_slow(struct snd_card *card, unsigned int numid)
+{
+        struct snd_kcontrol *kctl;
+
+        list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol) {
+                if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
+                        return kctl;
+        }
+        return NULL;
+}
+#endif /* !CONFIG_SND_CTL_FAST_LOOKUP */
 
 /**
@@ -679 +796 @@
 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card *card, unsigned int numid)
 {
-        struct snd_kcontrol *kctl;
-
         if (snd_BUG_ON(!card || !numid))
                 return NULL;
-        list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol) {
-                if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
-                        return kctl;
-        }
-        return NULL;
+#ifdef CONFIG_SND_CTL_FAST_LOOKUP
+        return xa_load(&card->ctl_numids, numid);
+#else
+        return snd_ctl_find_numid_slow(card, numid);
+#endif
 }
 EXPORT_SYMBOL(snd_ctl_find_numid);
@@ -713 +828 @@
         if (id->numid != 0)
                 return snd_ctl_find_numid(card, id->numid);
-        list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol) {
-                if (kctl->id.iface != id->iface)
-                        continue;
-                if (kctl->id.device != id->device)
-                        continue;
-                if (kctl->id.subdevice != id->subdevice)
-                        continue;
-                if (strncmp(kctl->id.name, id->name, sizeof(kctl->id.name)))
-                        continue;
-                if (kctl->id.index > id->index)
-                        continue;
-                if (kctl->id.index + kctl->count <= id->index)
-                        continue;
+#ifdef CONFIG_SND_CTL_FAST_LOOKUP
+        kctl = xa_load(&card->ctl_hash, get_ctl_id_hash(id));
+        if (kctl && elem_id_matches(kctl, id))
                 return kctl;
-        }
+        if (!card->ctl_hash_collision)
+                return NULL; /* we can rely on only hash table */
+#endif
+        /* no matching in hash table - try all as the last resort */
+        list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol)
+                if (elem_id_matches(kctl, id))
+                        return kctl;
         return NULL;
 }
@@ -869 +980 @@
 };
 
-#ifdef CONFIG_SND_CTL_VALIDATION
 /* fill the remaining snd_ctl_elem_value data with the given pattern */
 static void fill_remaining_elem_value(struct snd_ctl_elem_value *control,
@@ -886 +996 @@
                                   const struct snd_ctl_elem_value *control,
                                   const struct snd_ctl_elem_info *info,
-                                  int i)
+                                  int i, bool print_error)
 {
         long long lval, lmin, lmax, lstep;
@@ -920 +1030 @@
 
         if (lval < lmin || lval > lmax) {
-                dev_err(card->dev,
-                        "control %i:%i:%i:%s:%i: value out of range %lld (%lld/%lld) at count %i\n",
-                        control->id.iface, control->id.device,
-                        control->id.subdevice, control->id.name,
-                        control->id.index, lval, lmin, lmax, i);
+                if (print_error)
+                        dev_err(card->dev,
+                                "control %i:%i:%i:%s:%i: value out of range %lld (%lld/%lld) at count %i\n",
+                                control->id.iface, control->id.device,
+                                control->id.subdevice, control->id.name,
+                                control->id.index, lval, lmin, lmax, i);
                 return -EINVAL;
         }
@@ -930 +1041 @@
                 div64_u64_rem(lval, lstep, &rem);
                 if (rem) {
-                        dev_err(card->dev,
-                                "control %i:%i:%i:%s:%i: unaligned value %lld (step %lld) at count %i\n",
-                                control->id.iface, control->id.device,
-                                control->id.subdevice, control->id.name,
-                                control->id.index, lval, lstep, i);
+                        if (print_error)
+                                dev_err(card->dev,
+                                        "control %i:%i:%i:%s:%i: unaligned value %lld (step %lld) at count %i\n",
+                                        control->id.iface, control->id.device,
+                                        control->id.subdevice, control->id.name,
+                                        control->id.index, lval, lstep, i);
                         return -EINVAL;
                 }
@@ -942 +1054 @@
 }
 
-/* perform sanity checks to the given snd_ctl_elem_value object */
-static int sanity_check_elem_value(struct snd_card *card,
-                                   const struct snd_ctl_elem_value *control,
-                                   const struct snd_ctl_elem_info *info,
-                                   u32 pattern)
-{
-        size_t offset;
-        int i, ret = 0;
-        u32 *p;
+/* check whether the all input values are valid for the given elem value */
+static int sanity_check_input_values(struct snd_card *card,
+                                     const struct snd_ctl_elem_value *control,
+                                     const struct snd_ctl_elem_info *info,
+                                     bool print_error)
+{
+        int i, ret;
 
         switch (info->type) {
@@ -958 +1068 @@
         case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
                 for (i = 0; i < info->count; i++) {
-                        ret = sanity_check_int_value(card, control, info, i);
+                        ret = sanity_check_int_value(card, control, info, i,
+                                                     print_error);
                         if (ret < 0)
                                 return ret;
@@ -966 +1077 @@
                 break;
         }
+
+        return 0;
+}
+
+/* perform sanity checks to the given snd_ctl_elem_value object */
+static int sanity_check_elem_value(struct snd_card *card,
+                                   const struct snd_ctl_elem_value *control,
+                                   const struct snd_ctl_elem_info *info,
+                                   u32 pattern)
+{
+        size_t offset;
+        int ret;
+        u32 *p;
+
+        ret = sanity_check_input_values(card, control, info, true);
+        if (ret < 0)
+                return ret;
 
         /* check whether the remaining area kept untouched */
@@ -981 +1109 @@
         return ret;
 }
-#else
-static inline void fill_remaining_elem_value(struct snd_ctl_elem_value *control,
-                                             struct snd_ctl_elem_info *info,
-                                             u32 pattern)
-{
-}
-
-static inline int sanity_check_elem_value(struct snd_card *card,
-                                          struct snd_ctl_elem_value *control,
-                                          struct snd_ctl_elem_info *info,
-                                          u32 pattern)
-{
-        return 0;
-}
-#endif
 
 static int __snd_ctl_elem_info(struct snd_card *card,
@@ -1091 +1204 @@
         snd_ctl_build_ioff(&control->id, kctl, index_offset);
 
-#ifdef CONFIG_SND_CTL_VALIDATION
+#ifdef CONFIG_SND_CTL_DEBUG
         /* info is needed only for validation */
         memset(&info, 0, sizeof(info));
@@ -1168 +1281 @@
         snd_ctl_build_ioff(&control->id, kctl, index_offset);
         result = snd_power_ref_and_wait(card);
+        /* validate input values */
+#ifndef TARGET_OS2
+        if ((IS_ENABLED(CONFIG_SND_CTL_INPUT_VALIDATION) || defined(CONFIG_SND_CTL_INPUT_VALIDATION)) && !result) {
+#else
+        if (!result) {
+#endif
+                struct snd_ctl_elem_info info;
+
+                memset(&info, 0, sizeof(info));
+                info.id = control->id;
+                result = __snd_ctl_elem_info(card, kctl, &info, NULL);
+                if (!result)
+                        result = sanity_check_input_values(card, control, &info,
+                                                           false);
+        }
         if (!result)
                 result = kctl->put(kctl, control);
@@ -1944 +2072 @@
  *
  * called from each device manager like pcm.c, hwdep.c, etc.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn)
@@ -1956 +2086 @@
  * control-ioctls
  * @fcn: ioctl callback function
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn)
@@ -1991 +2123 @@
  * snd_ctl_unregister_ioctl - de-register the device-specific control-ioctls
  * @fcn: ioctl callback function to unregister
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn)
@@ -2003 +2137 @@
  * 32bit control-ioctls
  * @fcn: ioctl callback function to unregister
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn)
@@ -2058 +2194 @@
  * @module_name: Name of the kernel module (NULL == build-in)
  *
- * Return an error code when the module cannot be loaded.
+ * Return: zero if successful, or an error code when the module cannot be loaded
  */
 int snd_ctl_request_layer(const char *module_name)
@@ -2209 +2345 @@
         while (!list_empty(&card->controls)) {
                 control = snd_kcontrol(card->controls.next);
-                snd_ctl_remove(card, control);
-        }
+                __snd_ctl_remove(card, control, false);
+        }
+
+#ifdef CONFIG_SND_CTL_FAST_LOOKUP
+        xa_destroy(&card->ctl_numids);
+        xa_destroy(&card->ctl_hash);
+#endif
         up_write(&card->controls_rwsem);
         put_device(&card->ctl_dev);
@@ -2255 +2396 @@
  * This is a function that can be used as info callback for a standard
  * boolean control with a single mono channel.
+ *
+ * Return: Zero (always successful)
  */
 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol,
@@ -2275 +2418 @@
  * This is a function that can be used as info callback for a standard
  * boolean control with stereo two channels.
+ *
+ * Return: Zero (always successful)
  */
 int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol,
@@ -2298 +2443 @@
  * the caller has to fill @info->access.
  *
- * Return: Zero.
+ * Return: Zero (always successful)
  */
 int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels,

GPL/branches/uniaud32-exp/alsa-kernel/core/device.c

@@ -248 +248 @@
  * @SNDRV_DEV_DISCONNECTED is returned.
  * Or for a non-existing device, -1 is returned as an error.
+ *
+ * Return: the current state, or -1 if not found
  */
 int snd_device_get_state(struct snd_card *card, void *device_data)

GPL/branches/uniaud32-exp/alsa-kernel/core/info.c

@@ -873 +873 @@
  * This proc file entry will be registered via snd_card_register() call, and
  * it will be removed automatically at the card removal, too.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_card_rw_proc_new(struct snd_card *card, const char *name,

GPL/branches/uniaud32-exp/alsa-kernel/core/init.c

@@ -218 +218 @@
  * devres call orders.  You can use snd_card_free_on_error() helper for
  * handling it more easily.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_devm_card_new(struct device *parent, int idx, const char *xid,
@@ -252 +254 @@
  * the probe callback.  It's just a small helper for simplifying the error
  * handling with the managed devices.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_card_free_on_error(struct device *dev, int ret)
@@ -315 +319 @@
         INIT_LIST_HEAD(&card->controls);
         INIT_LIST_HEAD(&card->ctl_files);
+#ifdef CONFIG_SND_CTL_FAST_LOOKUP
+        xa_init(&card->ctl_numids);
+        xa_init(&card->ctl_hash);
+#endif
         spin_lock_init(&card->files_lock);
         INIT_LIST_HEAD(&card->files_list);
@@ -371 +379 @@
  * Returns a card object corresponding to the given index or NULL if not found.
  * Release the object via snd_card_unref().
+ *
+ * Return: a card object or NULL
  */
 struct snd_card *snd_card_ref(int idx)
@@ -612 +622 @@
  * is still in use, the function returns before freeing the resources.
  * The card resources will be freed when the refcount gets to zero.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_card_free_when_closed(struct snd_card *card)
@@ -781 +793 @@
 {
         struct snd_card *card = container_of(dev, struct snd_card, card_dev);
-        return scnprintf(buf, PAGE_SIZE, "%s\n", card->id);
+        return sysfs_emit(buf, "%s\n", card->id);
 }
 
@@ -819 +831 @@
 {
         struct snd_card *card = container_of(dev, struct snd_card, card_dev);
-        return scnprintf(buf, PAGE_SIZE, "%i\n", card->number);
+        return sysfs_emit(buf, "%i\n", card->number);
 }
 
@@ -839 +851 @@
  * @card: card instance
  * @group: attribute group to append
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_card_add_dev_attr(struct snd_card *card,

GPL/branches/uniaud32-exp/alsa-kernel/core/memalloc.c

@@ -366 +366 @@
  * SNDRV_DMA_TYPE_VMALLOC type.
  *
- * The function returns the snd_dma_buffer object at success, or NULL if failed.
+ * Return: the snd_dma_buffer object at success, or NULL if failed
  */
 struct snd_dma_buffer *

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm.c

@@ -220 +220 @@
  * snd_pcm_format_name - Return a name string for the given PCM format
  * @format: PCM format
+ *
+ * Return: the format name string
  */
 const char *snd_pcm_format_name(snd_pcm_format_t format)
@@ -1038 +1040 @@
         else
                 str = strs[pcm->dev_class];
-        return sprintf(buf, "%s\n", str);
+        return sysfs_emit(buf, "%s\n", str);
 }
 
@@ -1149 +1151 @@
  * called for each registered PCM devices.  This exists only for PCM OSS
  * emulation, so far.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_memory.c

@@ -359 +359 @@
  *
  * Upon successful buffer allocation and setup, the function returns 0.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_pcm_set_managed_buffer(struct snd_pcm_substream *substream, int type,
@@ -378 +380 @@
  * Do pre-allocation to all substreams of the given pcm for the specified DMA
  * type and size, and set the managed_buffer_alloc flag to each substream.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_pcm_set_managed_buffer_all(struct snd_pcm *pcm, int type,

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_native.c

@@ -3467 +3467 @@
  * and it allows only the limited set of ioctls (hw_params, sw_params,
  * prepare, start, drain, drop, forward).
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_pcm_kernel_ioctl(struct snd_pcm_substream *substream,
@@ -3871 +3873 @@
  * This is the default mmap handler for PCM data.  When mmap pcm_ops is NULL,
  * this function is invoked implicitly.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_pcm_lib_default_mmap(struct snd_pcm_substream *substream,
@@ -3897 +3901 @@
  * wants to mmap it, pass this function as mmap pcm_ops.  Note that this
  * is supposed to work only on limited architectures.
+ *
+ * Return: zero if successful, or a negative error code
  */
 int snd_pcm_lib_mmap_iomem(struct snd_pcm_substream *substream,

GPL/branches/uniaud32-exp/alsa-kernel/core/rawmidi.c

@@ -116 +116 @@
 static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
 {
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
         unsigned long flags;
         bool ready;
 
-        spin_lock_irqsave(&runtime->lock, flags);
-        ready = __snd_rawmidi_ready(runtime);
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
+        ready = __snd_rawmidi_ready(substream->runtime);
+        spin_unlock_irqrestore(&substream->lock, flags);
         return ready;
 }
@@ -144 +143 @@
 }
 
-/* buffer refcount management: call with runtime->lock held */
+/* buffer refcount management: call with substream->lock held */
 static inline void snd_rawmidi_buffer_ref(struct snd_rawmidi_runtime *runtime)
 {
@@ -153 +152 @@
 {
         runtime->buffer_ref--;
+}
+
+static void snd_rawmidi_buffer_ref_sync(struct snd_rawmidi_substream *substream)
+{
+        int loop = HZ;
+
+        spin_lock_irq(&substream->lock);
+        while (substream->runtime->buffer_ref) {
+                spin_unlock_irq(&substream->lock);
+                if (!--loop) {
+                        rmidi_err(substream->rmidi, "Buffer ref sync timeout\n");
+                        return;
+                }
+                schedule_timeout_uninterruptible(1);
+                spin_lock_irq(&substream->lock);
+        }
+        spin_unlock_irq(&substream->lock);
 }
 
@@ -163 +179 @@
                 return -ENOMEM;
         runtime->substream = substream;
-        spin_lock_init(&runtime->lock);
         init_waitqueue_head(&runtime->sleep);
         INIT_WORK(&runtime->event_work, snd_rawmidi_input_event_work);
@@ -217 +232 @@
 }
 
-static void reset_runtime_ptrs(struct snd_rawmidi_runtime *runtime,
+static void reset_runtime_ptrs(struct snd_rawmidi_substream *substream,
                                bool is_input)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&runtime->lock, flags);
-        __reset_runtime_ptrs(runtime, is_input);
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
+        if (substream->opened && substream->runtime)
+                __reset_runtime_ptrs(substream->runtime, is_input);
+        spin_unlock_irqrestore(&substream->lock, flags);
 }
 
@@ -230 +246 @@
 {
         snd_rawmidi_output_trigger(substream, 0);
-        reset_runtime_ptrs(substream->runtime, false);
+        reset_runtime_ptrs(substream, false);
         return 0;
 }
@@ -237 +253 @@
 int snd_rawmidi_drain_output(struct snd_rawmidi_substream *substream)
 {
-        int err;
+        int err = 0;
         long timeout;
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
-
-        err = 0;
-        runtime->drain = 1;
+        struct snd_rawmidi_runtime *runtime;
+
+        spin_lock_irq(&substream->lock);
+        runtime = substream->runtime;
+        if (!substream->opened || !runtime || !runtime->buffer) {
+                err = -EINVAL;
+        } else {
+                snd_rawmidi_buffer_ref(runtime);
+                runtime->drain = 1;
+        }
+        spin_unlock_irq(&substream->lock);
+        if (err < 0)
+                return err;
+
 #ifndef TARGET_OS2
         timeout = wait_event_interruptible_timeout(runtime->sleep,
@@ -250 +276 @@
         timeout = interruptible_sleep_on_timeout(&runtime->sleep, 10 * HZ);
 #endif
+
+        spin_lock_irq(&substream->lock);
         if (signal_pending(current))
                 err = -ERESTARTSYS;
@@ -259 +287 @@
         }
         runtime->drain = 0;
+        spin_unlock_irq(&substream->lock);
+
         if (err != -ERESTARTSYS) {
                 /* we need wait a while to make sure that Tx FIFOs are empty */
@@ -267 +297 @@
                 snd_rawmidi_drop_output(substream);
         }
+
+        spin_lock_irq(&substream->lock);
+        snd_rawmidi_buffer_unref(runtime);
+        spin_unlock_irq(&substream->lock);
+
         return err;
 }
@@ -274 +309 @@
 {
         snd_rawmidi_input_trigger(substream, 0);
-        reset_runtime_ptrs(substream->runtime, true);
+        reset_runtime_ptrs(substream, true);
         return 0;
 }
@@ -329 +364 @@
                         return err;
                 }
+                spin_lock_irq(&substream->lock);
                 substream->opened = 1;
                 substream->active_sensing = 0;
@@ -335 +371 @@
                 substream->pid = get_pid(task_pid(current));
                 rmidi->streams[substream->stream].substream_opened++;
+                spin_unlock_irq(&substream->lock);
         }
         substream->use_count++;
@@ -539 +576 @@
                                 snd_rawmidi_output_trigger(substream, 0);
                 }
-        }
+                snd_rawmidi_buffer_ref_sync(substream);
+        }
+        spin_lock_irq(&substream->lock);
+        substream->opened = 0;
+        substream->append = 0;
+        spin_unlock_irq(&substream->lock);
         substream->ops->close(substream);
         if (substream->runtime->private_free)
                 substream->runtime->private_free(substream);
         snd_rawmidi_runtime_free(substream);
-        substream->opened = 0;
-        substream->append = 0;
         put_pid(substream->pid);
         substream->pid = NULL;
@@ -696 +736 @@
 }
 
-static int resize_runtime_buffer(struct snd_rawmidi_runtime *runtime,
+static int resize_runtime_buffer(struct snd_rawmidi_substream *substream,
                                  struct snd_rawmidi_params *params,
                                  bool is_input)
 {
+        struct snd_rawmidi_runtime *runtime = substream->runtime;
         char *newbuf, *oldbuf;
         unsigned int framing = params->mode & SNDRV_RAWMIDI_MODE_FRAMING_MASK;
@@ -713 +754 @@
                 if (!newbuf)
                         return -ENOMEM;
-                spin_lock_irq(&runtime->lock);
+                spin_lock_irq(&substream->lock);
                 if (runtime->buffer_ref) {
-                        spin_unlock_irq(&runtime->lock);
+                        spin_unlock_irq(&substream->lock);
                         kvfree(newbuf);
                         return -EBUSY;
@@ -723 +764 @@
                 runtime->buffer_size = params->buffer_size;
                 __reset_runtime_ptrs(runtime, is_input);
-                spin_unlock_irq(&runtime->lock);
+                spin_unlock_irq(&substream->lock);
                 kvfree(oldbuf);
         }
@@ -733 +774 @@
                               struct snd_rawmidi_params *params)
 {
+        int err;
+
+        snd_rawmidi_drain_output(substream);
+        mutex_lock(&substream->rmidi->open_mutex);
         if (substream->append && substream->use_count > 1)
-                return -EBUSY;
-        snd_rawmidi_drain_output(substream);
-        substream->active_sensing = !params->no_active_sensing;
-        return resize_runtime_buffer(substream->runtime, params, false);
+                err = -EBUSY;
+        else
+                err = resize_runtime_buffer(substream, params, false);
+
+        if (!err)
+                substream->active_sensing = !params->no_active_sensing;
+        mutex_unlock(&substream->rmidi->open_mutex);
+        return err;
 }
 EXPORT_SYMBOL(snd_rawmidi_output_params);
@@ -748 +797 @@
         int err;
 
+        snd_rawmidi_drain_input(substream);
+        mutex_lock(&substream->rmidi->open_mutex);
         if (framing == SNDRV_RAWMIDI_MODE_FRAMING_NONE && clock_type != SNDRV_RAWMIDI_MODE_CLOCK_NONE)
-                return -EINVAL;
+                err = -EINVAL;
         else if (clock_type > SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW)
-                return -EINVAL;
-        if (framing > SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP)
-                return -EINVAL;
-        snd_rawmidi_drain_input(substream);
-        err = resize_runtime_buffer(substream->runtime, params, true);
-        if (err < 0)
-                return err;
-
-        substream->framing = framing;
-        substream->clock_type = clock_type;
+                err = -EINVAL;
+        else if (framing > SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP)
+                err = -EINVAL;
+        else
+                err = resize_runtime_buffer(substream, params, true);
+
+        if (!err) {
+                substream->framing = framing;
+                substream->clock_type = clock_type;
+        }
+        mutex_unlock(&substream->rmidi->open_mutex);
         return 0;
 }
@@ -773 +825 @@
         memset(status, 0, sizeof(*status));
         status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT;
-        spin_lock_irq(&runtime->lock);
+        spin_lock_irq(&substream->lock);
         status->avail = runtime->avail;
-        spin_unlock_irq(&runtime->lock);
+        spin_unlock_irq(&substream->lock);
         return 0;
 }
@@ -786 +838 @@
         memset(status, 0, sizeof(*status));
         status->stream = SNDRV_RAWMIDI_STREAM_INPUT;
-        spin_lock_irq(&runtime->lock);
+        spin_lock_irq(&substream->lock);
         status->avail = runtime->avail;
         status->xruns = runtime->xruns;
         runtime->xruns = 0;
-        spin_unlock_irq(&runtime->lock);
+        spin_unlock_irq(&substream->lock);
         return 0;
 }
@@ -1092 +1144 @@
         struct timespec64 ts64 = get_framing_tstamp(substream);
         int result = 0, count1;
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
-
-        if (!substream->opened)
-                return -EBADFD;
-        if (runtime->buffer == NULL) {
+        struct snd_rawmidi_runtime *runtime;
+
+        spin_lock_irqsave(&substream->lock, flags);
+        if (!substream->opened) {
+                result = -EBADFD;
+                goto unlock;
+        }
+        runtime = substream->runtime;
+        if (!runtime || !runtime->buffer) {
                 rmidi_dbg(substream->rmidi,
                           "snd_rawmidi_receive: input is not active!!!\n");
-                return -EINVAL;
-        }
-
-        spin_lock_irqsave(&runtime->lock, flags);
+                result = -EINVAL;
+                goto unlock;
+        }
+
         if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) {
                 result = receive_with_tstamp_framing(substream, buffer, count, &ts64);
@@ -1149 +1205 @@
                         wake_up(&runtime->sleep);
         }
-        spin_unlock_irqrestore(&runtime->lock, flags);
+ unlock:
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result;
 }
@@ -1164 +1221 @@
         int err = 0;
 
-        spin_lock_irqsave(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
         snd_rawmidi_buffer_ref(runtime);
         while (count > 0 && runtime->avail) {
@@ -1182 +1239 @@
                         memcpy(kernelbuf + result, runtime->buffer + appl_ptr, count1);
                 if (userbuf) {
-                        spin_unlock_irqrestore(&runtime->lock, flags);
+                        spin_unlock_irqrestore(&substream->lock, flags);
                         if (copy_to_user(userbuf + result,
                                          runtime->buffer + appl_ptr, count1))
                                 err = -EFAULT;
-                        spin_lock_irqsave(&runtime->lock, flags);
+                        spin_lock_irqsave(&substream->lock, flags);
                         if (err)
                                 goto out;
@@ -1195 +1252 @@
  out:
         snd_rawmidi_buffer_unref(runtime);
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result > 0 ? result : err;
 }
@@ -1224 +1281 @@
         result = 0;
         while (count > 0) {
-                spin_lock_irq(&runtime->lock);
+                spin_lock_irq(&substream->lock);
                 while (!__snd_rawmidi_ready(runtime)) {
                         wait_queue_entry_t wait;
 
                         if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
-                                spin_unlock_irq(&runtime->lock);
+                                spin_unlock_irq(&substream->lock);
                                 return result > 0 ? result : -EAGAIN;
                         }
@@ -1235 +1292 @@
                         add_wait_queue(&runtime->sleep, &wait);
                         set_current_state(TASK_INTERRUPTIBLE);
-                        spin_unlock_irq(&runtime->lock);
+                        spin_unlock_irq(&substream->lock);
                         schedule();
                         remove_wait_queue(&runtime->sleep, &wait);
@@ -1242 +1299 @@
                         if (signal_pending(current))
                                 return result > 0 ? result : -ERESTARTSYS;
-                        spin_lock_irq(&runtime->lock);
+                        spin_lock_irq(&substream->lock);
                         if (!runtime->avail) {
-                                spin_unlock_irq(&runtime->lock);
+                                spin_unlock_irq(&substream->lock);
                                 return result > 0 ? result : -EIO;
                         }
                 }
-                spin_unlock_irq(&runtime->lock);
+                spin_unlock_irq(&substream->lock);
                 count1 = snd_rawmidi_kernel_read1(substream,
                                                   (unsigned char __user *)buf,
@@ -1270 +1327 @@
 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream *substream)
 {
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
+        struct snd_rawmidi_runtime *runtime;
         int result;
         unsigned long flags;
 
-        if (runtime->buffer == NULL) {
+        spin_lock_irqsave(&substream->lock, flags);
+        runtime = substream->runtime;
+        if (!substream->opened || !runtime || !runtime->buffer) {
                 rmidi_dbg(substream->rmidi,
                           "snd_rawmidi_transmit_empty: output is not active!!!\n");
-                return 1;
-        }
-        spin_lock_irqsave(&runtime->lock, flags);
-        result = runtime->avail >= runtime->buffer_size;
-        spin_unlock_irqrestore(&runtime->lock, flags);
+                result = 1;
+        } else {
+                result = runtime->avail >= runtime->buffer_size;
+        }
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result;
 }
 EXPORT_SYMBOL(snd_rawmidi_transmit_empty);
 
-/**
+/*
  * __snd_rawmidi_transmit_peek - copy data from the internal buffer
  * @substream: the rawmidi substream
@@ -1294 +1353 @@
  * This is a variant of snd_rawmidi_transmit_peek() without spinlock.
  */
-int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
-                              unsigned char *buffer, int count)
+static int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
+                                       unsigned char *buffer, int count)
 {
         int result, count1;
@@ -1332 +1391 @@
         return result;
 }
-EXPORT_SYMBOL(__snd_rawmidi_transmit_peek);
 
 /**
@@ -1351 +1409 @@
                               unsigned char *buffer, int count)
 {
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
         int result;
         unsigned long flags;
 
-        spin_lock_irqsave(&runtime->lock, flags);
-        result = __snd_rawmidi_transmit_peek(substream, buffer, count);
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
+        if (!substream->opened || !substream->runtime)
+                result = -EBADFD;
+        else
+                result = __snd_rawmidi_transmit_peek(substream, buffer, count);
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result;
 }
 EXPORT_SYMBOL(snd_rawmidi_transmit_peek);
 
-/**
+/*
  * __snd_rawmidi_transmit_ack - acknowledge the transmission
  * @substream: the rawmidi substream
@@ -1369 +1429 @@
  * This is a variant of __snd_rawmidi_transmit_ack() without spinlock.
  */
-int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
+static int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream,
+                                      int count)
 {
         struct snd_rawmidi_runtime *runtime = substream->runtime;
@@ -1389 +1450 @@
         return count;
 }
-EXPORT_SYMBOL(__snd_rawmidi_transmit_ack);
 
 /**
@@ -1404 +1464 @@
 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
 {
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
         int result;
         unsigned long flags;
 
-        spin_lock_irqsave(&runtime->lock, flags);
-        result = __snd_rawmidi_transmit_ack(substream, count);
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
+        if (!substream->opened || !substream->runtime)
+                result = -EBADFD;
+        else
+                result = __snd_rawmidi_transmit_ack(substream, count);
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result;
 }
@@ -1428 +1490 @@
                          unsigned char *buffer, int count)
 {
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
         int result;
         unsigned long flags;
 
-        spin_lock_irqsave(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
         if (!substream->opened)
                 result = -EBADFD;
@@ -1442 +1503 @@
                         result = __snd_rawmidi_transmit_ack(substream, count);
         }
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result;
 }
@@ -1455 +1516 @@
 int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream)
 {
-        struct snd_rawmidi_runtime *runtime = substream->runtime;
+        struct snd_rawmidi_runtime *runtime;
         unsigned long flags;
         int count = 0;
 
-        spin_lock_irqsave(&runtime->lock, flags);
-        if (runtime->avail < runtime->buffer_size) {
+        spin_lock_irqsave(&substream->lock, flags);
+        runtime = substream->runtime;
+        if (substream->opened && runtime &&
+            runtime->avail < runtime->buffer_size) {
                 count = runtime->buffer_size - runtime->avail;
                 __snd_rawmidi_transmit_ack(substream, count);
         }
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_unlock_irqrestore(&substream->lock, flags);
         return count;
 }
@@ -1485 +1548 @@
 
         result = 0;
-        spin_lock_irqsave(&runtime->lock, flags);
+        spin_lock_irqsave(&substream->lock, flags);
         if (substream->append) {
                 if ((long)runtime->avail < count) {
-                        spin_unlock_irqrestore(&runtime->lock, flags);
+                        spin_unlock_irqrestore(&substream->lock, flags);
                         return -EAGAIN;
                 }
@@ -1510 +1573 @@
                                kernelbuf + result, count1);
                 else if (userbuf) {
-                        spin_unlock_irqrestore(&runtime->lock, flags);
+                        spin_unlock_irqrestore(&substream->lock, flags);
                         if (copy_from_user(runtime->buffer + appl_ptr,
                                            userbuf + result, count1)) {
-                                spin_lock_irqsave(&runtime->lock, flags);
+                                spin_lock_irqsave(&substream->lock, flags);
                                 result = result > 0 ? result : -EFAULT;
                                 goto __end;
                         }
-                        spin_lock_irqsave(&runtime->lock, flags);
+                        spin_lock_irqsave(&substream->lock, flags);
                 }
                 result += count1;
@@ -1525 +1588 @@
         count1 = runtime->avail < runtime->buffer_size;
         snd_rawmidi_buffer_unref(runtime);
-        spin_unlock_irqrestore(&runtime->lock, flags);
+        spin_unlock_irqrestore(&substream->lock, flags);
         if (count1)
                 snd_rawmidi_output_trigger(substream, 1);
@@ -1555 +1618 @@
         result = 0;
         while (count > 0) {
-                spin_lock_irq(&runtime->lock);
+                spin_lock_irq(&substream->lock);
                 while (!snd_rawmidi_ready_append(substream, count)) {
                         wait_queue_entry_t wait;
 
                         if (file->f_flags & O_NONBLOCK) {
-                                spin_unlock_irq(&runtime->lock);
+                                spin_unlock_irq(&substream->lock);
                                 return result > 0 ? result : -EAGAIN;
                         }
@@ -1566 +1629 @@
                         add_wait_queue(&runtime->sleep, &wait);
                         set_current_state(TASK_INTERRUPTIBLE);
-                        spin_unlock_irq(&runtime->lock);
+                        spin_unlock_irq(&substream->lock);
                         timeout = schedule_timeout(30 * HZ);
                         remove_wait_queue(&runtime->sleep, &wait);
@@ -1573 +1636 @@
                         if (signal_pending(current))
                                 return result > 0 ? result : -ERESTARTSYS;
-                        spin_lock_irq(&runtime->lock);
+                        spin_lock_irq(&substream->lock);
                         if (!runtime->avail && !timeout) {
-                                spin_unlock_irq(&runtime->lock);
+                                spin_unlock_irq(&substream->lock);
                                 return result > 0 ? result : -EIO;
                         }
                 }
-                spin_unlock_irq(&runtime->lock);
+                spin_unlock_irq(&substream->lock);
                 count1 = snd_rawmidi_kernel_write1(substream, buf, NULL, count);
                 if (count1 < 0)
@@ -1590 +1653 @@
         }
         if (file->f_flags & O_DSYNC) {
-                spin_lock_irq(&runtime->lock);
+                spin_lock_irq(&substream->lock);
                 while (runtime->avail != runtime->buffer_size) {
                         wait_queue_entry_t wait;
@@ -1598 +1661 @@
                         add_wait_queue(&runtime->sleep, &wait);
                         set_current_state(TASK_INTERRUPTIBLE);
-                        spin_unlock_irq(&runtime->lock);
+                        spin_unlock_irq(&substream->lock);
                         timeout = schedule_timeout(30 * HZ);
                         remove_wait_queue(&runtime->sleep, &wait);
@@ -1605 +1668 @@
                         if (runtime->avail == last_avail && !timeout)
                                 return result > 0 ? result : -EIO;
-                        spin_lock_irq(&runtime->lock);
-                }
-                spin_unlock_irq(&runtime->lock);
+                        spin_lock_irq(&substream->lock);
+                }
+                spin_unlock_irq(&substream->lock);
         }
         return result;
@@ -1678 +1741 @@
                                     pid_vnr(substream->pid));
                                 runtime = substream->runtime;
-                                spin_lock_irq(&runtime->lock);
+                                spin_lock_irq(&substream->lock);
                                 buffer_size = runtime->buffer_size;
                                 avail = runtime->avail;
-                                spin_unlock_irq(&runtime->lock);
+                                spin_unlock_irq(&substream->lock);
                                 snd_iprintf(buffer,
                                     "  Mode         : %s\n"
@@ -1705 +1768 @@
                                             pid_vnr(substream->pid));
                                 runtime = substream->runtime;
-                                spin_lock_irq(&runtime->lock);
+                                spin_lock_irq(&substream->lock);
                                 buffer_size = runtime->buffer_size;
                                 avail = runtime->avail;
                                 xruns = runtime->xruns;
-                                spin_unlock_irq(&runtime->lock);
+                                spin_unlock_irq(&substream->lock);
                                 snd_iprintf(buffer,
                                             "  Buffer size  : %lu\n"
@@ -1763 +1826 @@
                 substream->rmidi = rmidi;
                 substream->pstr = stream;
+                spin_lock_init(&substream->lock);
                 list_add_tail(&substream->list, &stream->substreams);
                 stream->substream_count++;

GPL/branches/uniaud32-exp/alsa-kernel/core/vmaster.c

@@ -500 +500 @@
  *
  * Apply the function @func to each follower kctl of the given vmaster kctl.
- * Returns 0 if successful, or a negative error code.
+ *
+ * Return: 0 if successful, or a negative error code
  */
 int snd_ctl_apply_vmaster_followers(struct snd_kcontrol *kctl,

GPL/branches/uniaud32-exp/alsa-kernel/hda/ext/hdac_ext_controller.c

@@ -14 +14 @@
 #include <sound/hda_register.h>
 #include <sound/hdaudio_ext.h>
-
-/*
- * maximum HDAC capablities we should parse to avoid endless looping:
- * currently we have 4 extended caps, so this is future proof for now.
- * extend when this limit is seen meeting in real HW
- */
-#define HDAC_MAX_CAPS 10
 
 /*

GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_bus.c

@@ -194 +194 @@
                         continue;
                 codec = bus->caddr_tbl[caddr & 0x0f];
-                if (!codec || !codec->dev.driver)
+                if (!codec || !codec->registered)
                         continue;
                 spin_unlock_irq(&bus->reg_lock);

GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_controller.c

@@ -481 +481 @@
                 snd_hdac_stream_updateb(azx_dev, SD_CTL, SD_INT_MASK, 0);
 
-        /* disable SIE for all streams */
-        snd_hdac_chip_writeb(bus, INTCTL, 0);
-
-        /* disable controller CIE and GIE */
-        snd_hdac_chip_updatel(bus, INTCTL, AZX_INT_CTRL_EN | AZX_INT_GLOBAL_EN, 0);
+        /* disable SIE for all streams & disable controller CIE and GIE */
+        snd_hdac_chip_writel(bus, INTCTL, 0);
 }
 

GPL/branches/uniaud32-exp/alsa-kernel/hda/trace.h

@@ -20 +20 @@
         TP_PROTO(struct hdac_bus *bus, unsigned int cmd),
         TP_ARGS(bus, cmd),
-        TP_STRUCT__entry(__dynamic_array(char, msg, HDAC_MSG_MAX)),
+        TP_STRUCT__entry(
+                __string(name, dev_name((bus)->dev))
+                __field(u32, cmd)
+        ),
         TP_fast_assign(
-                snprintf(__get_str(msg), HDAC_MSG_MAX,
-                         "[%s:%d] val=0x%08x",
-                         dev_name((bus)->dev), (cmd) >> 28, cmd);
+                __assign_str(name, dev_name((bus)->dev));
+                __entry->cmd = cmd;
         ),
-        TP_printk("%s", __get_str(msg))
+        TP_printk("[%s:%d] val=0x%08x", __get_str(name), __entry->cmd >> 28, __entry->cmd)
 );
 
@@ -32 +34 @@
         TP_PROTO(struct hdac_bus *bus, unsigned int addr, unsigned int res),
         TP_ARGS(bus, addr, res),
-        TP_STRUCT__entry(__dynamic_array(char, msg, HDAC_MSG_MAX)),
+        TP_STRUCT__entry(
+                __string(name, dev_name((bus)->dev))
+                __field(u32, addr)
+                __field(u32, res)
+        ),
         TP_fast_assign(
-                snprintf(__get_str(msg), HDAC_MSG_MAX,
-                         "[%s:%d] val=0x%08x",
-                         dev_name((bus)->dev), addr, res);
+                __assign_str(name, dev_name((bus)->dev));
+                __entry->addr = addr;
+                __entry->res = res;
         ),
-        TP_printk("%s", __get_str(msg))
+        TP_printk("[%s:%d] val=0x%08x", __get_str(name), __entry->addr, __entry->res)
 );
 
@@ -44 +50 @@
         TP_PROTO(struct hdac_bus *bus, u32 res, u32 res_ex),
         TP_ARGS(bus, res, res_ex),
-        TP_STRUCT__entry(__dynamic_array(char, msg, HDAC_MSG_MAX)),
+        TP_STRUCT__entry(
+                __string(name, dev_name((bus)->dev))
+                __field(u32, res)
+                __field(u32, res_ex)
+        ),
         TP_fast_assign(
-                snprintf(__get_str(msg), HDAC_MSG_MAX,
-                         "[%s:%d] res=0x%08x, res_ex=0x%08x",
-                         dev_name((bus)->dev), res_ex & 0x0f, res, res_ex);
+                __assign_str(name, dev_name((bus)->dev));
+                __entry->res = res;
+                __entry->res_ex = res_ex;
         ),
-        TP_printk("%s", __get_str(msg))
+        TP_printk("[%s:%d] res=0x%08x, res_ex=0x%08x", __get_str(name),
+                  __entry->res_ex & 0x0f, __entry->res, __entry->res_ex)
 );
 

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/config.h

@@ -23 +23 @@
 #define CONFIG_PM
 #define CONFIG_PM_SLEEP
+#define CONFIG_SND_CTL_INPUT_VALIDATION 0
 #ifdef DEBUG
 #define CONFIG_SND_DEBUG_DETECT

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/control.h

@@ -24 +24 @@
 
 /* internal flag for skipping validations */
-#ifdef CONFIG_SND_CTL_VALIDATION
+#ifdef CONFIG_SND_CTL_DEBUG
 #define SNDRV_CTL_ELEM_ACCESS_SKIP_CHECK        (1 << 24)
 #define snd_ctl_skip_validation(info) \

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/core.h

@@ -18 +18 @@
 #include <linux/stringify.h>
 #include <linux/printk.h>
+#include <linux/xarray.h>
 
 /* number of supported soundcards */
@@ -107 +108 @@
         struct list_head controls;      /* all controls for this card */
         struct list_head ctl_files;     /* active control files */
+#ifdef CONFIG_SND_CTL_FAST_LOOKUP
+        struct xarray ctl_numids;       /* hash table for numids */
+        struct xarray ctl_hash;         /* hash table for ctl id matching */
+        bool ctl_hash_collision;        /* ctl_hash collision seen? */
+#endif
 
         struct snd_info_entry *proc_root;       /* root for soundcard specific files */

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/dmaengine_pcm.h

@@ -16 +16 @@
  *   substream
  * @substream: PCM substream
+ *
+ * Return: DMA transfer direction
  */
 static inline enum dma_transfer_direction

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/hda_codec.h

@@ -232 +232 @@
         unsigned int configured:1; /* codec was configured */
         unsigned int in_freeing:1; /* being released */
-        unsigned int registered:1; /* codec was registered */
         unsigned int display_power_control:1; /* needs display power */
         unsigned int spdif_status_reset :1; /* needs to toggle SPDIF for each

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/hdaudio.h

@@ -94 +94 @@
         bool caps_overwriting:1; /* caps overwrite being in process */
         bool cache_coef:1;      /* cache COEF read/write too */
+        unsigned int registered:1; /* codec was registered */
 };
 

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/hdmi-codec.h

@@ -33 +33 @@
         unsigned int bit_clk_inv:1;
         unsigned int frame_clk_inv:1;
-        unsigned int bit_clk_master:1;
-        unsigned int frame_clk_master:1;
+        unsigned int bit_clk_provider:1;
+        unsigned int frame_clk_provider:1;
         /* bit_fmt could be standard PCM format or
          * IEC958 encoded format. ALSA IEC958 plugin will pass

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/madera-pdata.h

@@ -10 +10 @@
 #define MADERA_CODEC_PDATA_H
 
-#include <linux/kernel.h>
+#include <linux/types.h>
 
 #define MADERA_MAX_INPUT                6

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/pcm.h

@@ -608 +608 @@
  * @substream: substream to check
  *
- * Returns true if the given substream is being linked with others.
+ * Return: true if the given substream is being linked with others
  */
 static inline int snd_pcm_stream_linked(struct snd_pcm_substream *substream)
@@ -681 +681 @@
  * @substream: substream to check
  *
- * Returns true if the given substream is in the state RUNNING, or in the
+ * Return: true if the given substream is in the state RUNNING, or in the
  * state DRAINING for playback.
  */
@@ -695 +695 @@
  * @runtime: PCM runtime instance
  * @size: size in bytes
+ *
+ * Return: the size in samples
  */
 static inline ssize_t bytes_to_samples(struct snd_pcm_runtime *runtime, ssize_t size)
@@ -705 +707 @@
  * @runtime: PCM runtime instance
  * @size: size in bytes
+ *
+ * Return: the size in frames
  */
 static inline snd_pcm_sframes_t bytes_to_frames(struct snd_pcm_runtime *runtime, ssize_t size)
@@ -715 +719 @@
  * @runtime: PCM runtime instance
  * @size: size in samples
+ *
+ * Return: the byte size
  */
 static inline ssize_t samples_to_bytes(struct snd_pcm_runtime *runtime, ssize_t size)
@@ -725 +731 @@
  * @runtime: PCM runtime instance
  * @size: size in frames
+ *
+ * Return: the byte size
  */
 static inline ssize_t frames_to_bytes(struct snd_pcm_runtime *runtime, snd_pcm_sframes_t size)
@@ -735 +743 @@
  * @runtime: PCM runtime instance
  * @bytes: size in bytes
+ *
+ * Return: true if aligned, or false if not
  */
 static inline int frame_aligned(struct snd_pcm_runtime *runtime, ssize_t bytes)
@@ -744 +754 @@
  * snd_pcm_lib_buffer_bytes - Get the buffer size of the current PCM in bytes
  * @substream: PCM substream
+ *
+ * Return: buffer byte size
  */
 static inline size_t snd_pcm_lib_buffer_bytes(struct snd_pcm_substream *substream)
@@ -754 +766 @@
  * snd_pcm_lib_period_bytes - Get the period size of the current PCM in bytes
  * @substream: PCM substream
+ *
+ * Return: period byte size
  */
 static inline size_t snd_pcm_lib_period_bytes(struct snd_pcm_substream *substream)
@@ -766 +780 @@
  *
  * Result is between 0 ... (boundary - 1)
+ *
+ * Return: available frame size
  */
 static inline snd_pcm_uframes_t snd_pcm_playback_avail(struct snd_pcm_runtime *runtime)
@@ -795 +811 @@
  *
  * Result is between 0 ... (boundary - 1)
+ *
+ * Return: available frame size
  */
 static inline snd_pcm_uframes_t snd_pcm_capture_avail(struct snd_pcm_runtime *runtime)
@@ -807 +825 @@
  * snd_pcm_playback_hw_avail - Get the queued space for playback
  * @runtime: PCM runtime instance
+ *
+ * Return: available frame size
  */
 static inline snd_pcm_sframes_t snd_pcm_playback_hw_avail(struct snd_pcm_runtime *runtime)
@@ -816 +836 @@
  * snd_pcm_capture_hw_avail - Get the free space for capture
  * @runtime: PCM runtime instance
+ *
+ * Return: available frame size
  */
 static inline snd_pcm_sframes_t snd_pcm_capture_hw_avail(struct snd_pcm_runtime *runtime)
@@ -955 +977 @@
  * params_channels - Get the number of channels from the hw params
  * @p: hw params
+ *
+ * Return: the number of channels
  */
 static inline unsigned int params_channels(const struct snd_pcm_hw_params *p)
@@ -964 +988 @@
  * params_rate - Get the sample rate from the hw params
  * @p: hw params
+ *
+ * Return: the sample rate
  */
 static inline unsigned int params_rate(const struct snd_pcm_hw_params *p)
@@ -973 +999 @@
  * params_period_size - Get the period size (in frames) from the hw params
  * @p: hw params
+ *
+ * Return: the period size in frames
  */
 static inline unsigned int params_period_size(const struct snd_pcm_hw_params *p)
@@ -982 +1010 @@
  * params_periods - Get the number of periods from the hw params
  * @p: hw params
+ *
+ * Return: the number of periods
  */
 static inline unsigned int params_periods(const struct snd_pcm_hw_params *p)
@@ -991 +1021 @@
  * params_buffer_size - Get the buffer size (in frames) from the hw params
  * @p: hw params
+ *
+ * Return: the buffer size in frames
  */
 static inline unsigned int params_buffer_size(const struct snd_pcm_hw_params *p)
@@ -1000 +1032 @@
  * params_buffer_bytes - Get the buffer size (in bytes) from the hw params
  * @p: hw params
+ *
+ * Return: the buffer size in bytes
  */
 static inline unsigned int params_buffer_bytes(const struct snd_pcm_hw_params *p)
@@ -1262 +1296 @@
  * allocation of a larger buffer unlike the standard one.
  * The function may return -ENOMEM error, hence the caller must check it.
+ *
+ * Return: zero if successful, or a negative error code
  */
 static inline int __must_check
@@ -1280 +1316 @@
  * all substream.  If any of allocation fails, it returns -ENOMEM, hence the
  * caller must check the return value.
+ *
+ * Return: zero if successful, or a negative error code
  */
 static inline int __must_check
@@ -1336 +1374 @@
  * @substream: PCM substream
  * @ofs: byte offset
+ *
+ * Return: DMA address
  */
 static inline dma_addr_t
@@ -1349 +1389 @@
  * @ofs: byte offset
  * @size: byte size to examine
+ *
+ * Return: chunk size
  */
 static inline unsigned int
@@ -1414 +1456 @@
 
 /**
- * snd_pcm_stream_str - Get a string naming the direction of a stream
- * @substream: the pcm substream instance
- *
- * Return: A string naming the direction of the stream.
- */
-static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
-{
-        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+ * snd_pcm_direction_name - Get a string naming the direction of a stream
+ * @direction: Stream's direction, one of SNDRV_PCM_STREAM_XXX
+ *
+ * Returns a string naming the direction of the stream.
+ */
+static inline const char *snd_pcm_direction_name(int direction)
+{
+        if (direction == SNDRV_PCM_STREAM_PLAYBACK)
                 return "Playback";
         else
                 return "Capture";
+}
+
+/**
+ * snd_pcm_stream_str - Get a string naming the direction of a stream
+ * @substream: the pcm substream instance
+ *
+ * Return: A string naming the direction of the stream.
+ */
+static inline const char *snd_pcm_stream_str(struct snd_pcm_substream *substream)
+{
+        return snd_pcm_direction_name(substream->stream);
 }
 
@@ -1451 +1504 @@
  * @info: chmap information
  * @idx: the substream number index
+ *
+ * Return: the matched PCM substream, or NULL if not found
  */
 static inline struct snd_pcm_substream *
@@ -1481 +1536 @@
  * pcm_format_to_bits - Strong-typed conversion of pcm_format to bitwise
  * @pcm_format: PCM format
+ *
+ * Return: 64bit mask corresponding to the given PCM format
  */
 static inline u64 pcm_format_to_bits(snd_pcm_format_t pcm_format)

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/rawmidi.h

@@ -64 +64 @@
         int buffer_ref;         /* buffer reference count */
         /* misc */
-        spinlock_t lock;
         wait_queue_head_t sleep;
         /* event handler (new bytes, input only) */
@@ -86 +85 @@
         int use_count;                  /* use counter (for output) */
         size_t bytes;
+        spinlock_t lock;
         struct snd_rawmidi *rmidi;
         struct snd_rawmidi_str *pstr;
@@ -157 +157 @@
 int snd_rawmidi_transmit(struct snd_rawmidi_substream *substream,
                          unsigned char *buffer, int count);
-int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream *substream,
-                              unsigned char *buffer, int count);
-int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream,
-                               int count);
 int snd_rawmidi_proceed(struct snd_rawmidi_substream *substream);
 

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/simple_card_utils.h

@@ -52 +52 @@
         int codecs;
         int platforms;
-        int c2c;
 };
 
@@ -65 +64 @@
                 struct asoc_simple_data adata;
                 struct snd_soc_codec_conf *codec_conf;
-                struct snd_soc_pcm_stream *c2c_conf;
                 struct prop_nums num;
                 unsigned int mclk_fs;
@@ -76 +74 @@
         struct snd_soc_dai_link_component dummy;
         struct snd_soc_codec_conf *codec_conf;
-        struct snd_soc_pcm_stream *c2c_conf;
         struct gpio_desc *pa_gpio;
         const struct snd_soc_ops *ops;
@@ -174 +171 @@
                                   int is_single_links);
 
-int asoc_simple_clean_reference(struct snd_soc_card *card);
+void asoc_simple_clean_reference(struct snd_soc_card *card);
 
 void asoc_simple_convert_fixup(struct asoc_simple_data *data,

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-acpi-intel-match.h

@@ -31 +31 @@
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_jsl_machines[];
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_adl_machines[];
+extern struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_machines[];
 
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_cnl_sdw_machines[];
@@ -38 +39 @@
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_tgl_sdw_machines[];
 extern struct snd_soc_acpi_mach snd_soc_acpi_intel_adl_sdw_machines[];
+extern struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_sdw_machines[];
 
 /*

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-component.h

@@ -180 +180 @@
          */
         unsigned int endianness:1;
-        unsigned int non_legacy_dai_naming:1;
+        unsigned int legacy_dai_naming:1;
 
         /* this component uses topology and ignore machine driver FEs */
@@ -347 +347 @@
 {
         return regcache_sync(component->regmap);
-}
-
-static inline int snd_soc_component_is_codec(struct snd_soc_component *component)
-{
-        return component->driver->non_legacy_dai_naming;
 }
 

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc-dai.h

@@ -124 +124 @@
 #define SND_SOC_DAIFMT_CBM_CFS          SND_SOC_DAIFMT_CBP_CFC
 #define SND_SOC_DAIFMT_CBS_CFS          SND_SOC_DAIFMT_CBC_CFC
+
+/* when passed to set_fmt directly indicate if the device is provider or consumer */
+#define SND_SOC_DAIFMT_BP_FP            SND_SOC_DAIFMT_CBP_CFP
+#define SND_SOC_DAIFMT_BC_FP            SND_SOC_DAIFMT_CBC_CFP
+#define SND_SOC_DAIFMT_BP_FC            SND_SOC_DAIFMT_CBP_CFC
+#define SND_SOC_DAIFMT_BC_FC            SND_SOC_DAIFMT_CBC_CFC
 
 /* Describes the possible PCM format */

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/soc.h

@@ -137 +137 @@
         .private_value = SOC_DOUBLE_VALUE(reg, shift_left, shift_right, \
                                           max, invert, 0) }
+#define SOC_DOUBLE_SX_TLV(xname, xreg, shift_left, shift_right, xmin, xmax, tlv_array) \
+{       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
+        .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
+        SNDRV_CTL_ELEM_ACCESS_READWRITE, \
+        .tlv.p  = (tlv_array), \
+        .info = snd_soc_info_volsw_sx, \
+        .get = snd_soc_get_volsw_sx, \
+        .put = snd_soc_put_volsw_sx, \
+        .private_value = (unsigned long)&(struct soc_mixer_control) \
+                {.reg = xreg, .rreg = xreg, \
+                .shift = shift_left, .rshift = shift_right, \
+                .max = xmax, .min = xmin} }
 #define SOC_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
@@ -415 +427 @@
 
 int snd_soc_register_card(struct snd_soc_card *card);
-int snd_soc_unregister_card(struct snd_soc_card *card);
+void snd_soc_unregister_card(struct snd_soc_card *card);
 int devm_snd_soc_register_card(struct device *dev, struct snd_soc_card *card);
 #ifdef CONFIG_PM_SLEEP
@@ -915 +927 @@
         int (*probe)(struct snd_soc_card *card);
         int (*late_probe)(struct snd_soc_card *card);
+        void (*fixup_controls)(struct snd_soc_card *card);
         int (*remove)(struct snd_soc_card *card);
 

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/sof.h

@@ -139 +139 @@
         struct snd_sof_dsp_ops *ops;
         int (*ops_init)(struct snd_sof_dev *sdev);
+        void (*ops_free)(struct snd_sof_dev *sdev);
 };
 

GPL/branches/uniaud32-exp/alsa-kernel/include/sound/version.h

@@ -1 +1 @@
 /* include/version.h */
-#define CONFIG_SND_VERSION "5.19.12"
+#define CONFIG_SND_VERSION "6.0"
 #define CONFIG_SND_DATE ""

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/asound.h

@@ -1150 +1150 @@
         unsigned int length;    /* in bytes aligned to 4 */
 #ifndef TARGET_OS2
-        unsigned int tlv[0];    /* first TLV */
+        unsigned int tlv[];     /* first TLV */
 #else
         unsigned int tlv[1];    /* first TLV */

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/compress_offload.h

@@ -124 +124 @@
 
 /**
- * enum sndrv_compress_encoder
+ * enum sndrv_compress_encoder - encoder metadata key
  * @SNDRV_COMPRESS_ENCODER_PADDING: no of samples appended by the encoder at the
  * end of the track

GPL/branches/uniaud32-exp/alsa-kernel/include/uapi/sound/compress_params.h

@@ -251 +251 @@
 
 /**
- * struct snd_enc_vorbis
+ * struct snd_enc_vorbis - Vorbis encoder parameters
  * @quality: Sets encoding quality to n, between -1 (low) and 10 (high).
  * In the default mode of operation, the quality level is 3.
@@ -280 +280 @@
 
 /**
- * struct snd_enc_real
+ * struct snd_enc_real - RealAudio encoder parameters
  * @quant_bits: number of coupling quantization bits in the stream
  * @start_region: coupling start region in the stream
@@ -295 +295 @@
 
 /**
- * struct snd_enc_flac
+ * struct snd_enc_flac - FLAC encoder parameters
  * @num: serial number, valid only for OGG formats
  *      needs to be set by application

GPL/branches/uniaud32-exp/alsa-kernel/pci/emu10k1/memory.c

@@ -325 +325 @@
         }
         /* fill buffer addresses but pointers are not stored so that
-         * snd_free_pci_page() is not called in in synth_free()
+         * snd_free_pci_page() is not called in synth_free()
          */
         idx = 0;

GPL/branches/uniaud32-exp/alsa-kernel/pci/ens1370.c

@@ -9 +9 @@
  * for ens1371 only ( FIXME )
  * derived from cs4281.c, atiixp.c and via82xx.c
- * using http://www.alsa-project.org/~tiwai/writing-an-alsa-driver/ 
+ * using https://www.kernel.org/doc/html/latest/sound/kernel-api/writing-an-alsa-driver.html
  * by Kurt J. Bosch
  */

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_bind.c

@@ -253 +253 @@
         hda_nid_t nid;
 
+        /*
+         * For ASoC users, if snd_hda_hdmi_codec module is denylisted and any
+         * event causes i915 enumeration to fail, ->wcaps remains uninitialized.
+         */
+        if (!codec->wcaps)
+                return true;
+
         for_each_hda_codec_node(nid, codec) {
                 unsigned int wcaps = get_wcaps(codec, nid);

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_codec.c

@@ -785 +785 @@
 void snd_hda_codec_cleanup_for_unbind(struct hda_codec *codec)
 {
-        if (codec->registered) {
+        if (codec->core.registered) {
                 /* pm_runtime_put() is called in snd_hdac_device_exit() */
                 pm_runtime_get_noresume(hda_codec_dev(codec));
                 pm_runtime_disable(hda_codec_dev(codec));
-                codec->registered = 0;
+                codec->core.registered = 0;
         }
 
@@ -838 +838 @@
 void snd_hda_codec_register(struct hda_codec *codec)
 {
-        if (codec->registered)
+        if (codec->core.registered)
                 return;
         if (device_is_registered(hda_codec_dev(codec))) {
@@ -845 +845 @@
                 /* it was powered up in snd_hda_codec_new(), now all done */
                 snd_hda_power_down(codec);
-                codec->registered = 1;
+                codec->core.registered = 1;
         }
 }
@@ -963 +963 @@
 {
         struct hda_codec *codec;
+        int ret;
 
         codec = snd_hda_codec_device_init(bus, codec_addr, "hdaudioC%dD%d",
@@ -970 +971 @@
         *codecp = codec;
 
-        return snd_hda_codec_device_new(bus, card, codec_addr, *codecp, true);
+        ret = snd_hda_codec_device_new(bus, card, codec_addr, *codecp, true);
+        if (ret)
+                put_device(hda_codec_dev(*codecp));
+
+        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_new);
@@ -1025 +1030 @@
         if (codec->bus->modelname) {
                 codec->modelname = kstrdup(codec->bus->modelname, GFP_KERNEL);
-                if (!codec->modelname) {
-                        err = -ENOMEM;
-                        goto error;
-                }
+                if (!codec->modelname)
+                        return -ENOMEM;
         }
 
@@ -1034 +1037 @@
         err = read_widget_caps(codec, fg);
         if (err < 0)
-                goto error;
+                return err;
         err = read_pin_defaults(codec);
         if (err < 0)
-                goto error;
+                return err;
 
         /* power-up all before initialization */
@@ -1055 +1058 @@
                 err = snd_device_new(card, SNDRV_DEV_CODEC, codec, &dev_ops);
                 if (err < 0)
-                        goto error;
-        }
-
+                        return err;
+        }
+
+#ifdef CONFIG_PM
         /* PM runtime needs to be enabled later after binding codec */
-        pm_runtime_forbid(&codec->core.dev);
-
-        return 0;
-
- error:
-        put_device(hda_codec_dev(codec));
-        return err;
+        if (codec->core.dev.power.runtime_auto)
+                pm_runtime_forbid(&codec->core.dev);
+        else
+                /* Keep the usage_count consistent across subsequent probing */
+                pm_runtime_get_noresume(&codec->core.dev);
+#endif
+
+        return 0;
 }
 EXPORT_SYMBOL_GPL(snd_hda_codec_device_new);
@@ -3067 +3072 @@
 
         /* Skip the shutdown if codec is not registered */
-        if (!codec->registered)
+        if (!codec->core.registered)
                 return;
 

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_component2.h

@@ -15 +15 @@
         struct device *dev;
         char name[HDA_MAX_NAME_SIZE];
+        struct hda_codec *codec;
         void (*playback_hook)(struct device *dev, int action);
-        int (*set_channel_map)(struct device *dev, unsigned int rx_num, unsigned int *rx_slot,
-                                unsigned int tx_num, unsigned int *tx_slot);
+        int (*suspend_hook)(struct device *dev);
+        int (*resume_hook)(struct device *dev);
 };

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/hda_sysfs.c

@@ -34 +34 @@
         struct hda_codec *codec = dev_get_drvdata(dev);
         snd_hda_update_power_acct(codec);
-        return sprintf(buf, "%u\n", jiffies_to_msecs(codec->power_on_acct));
+        return sysfs_emit(buf, "%u\n", jiffies_to_msecs(codec->power_on_acct));
 }
 
@@ -43 +43 @@
         struct hda_codec *codec = dev_get_drvdata(dev);
         snd_hda_update_power_acct(codec);
-        return sprintf(buf, "%u\n", jiffies_to_msecs(codec->power_off_acct));
+        return sysfs_emit(buf, "%u\n", jiffies_to_msecs(codec->power_off_acct));
 }
 
@@ -56 +56 @@
 {                                                               \
         struct hda_codec *codec = dev_get_drvdata(dev);         \
-        return sprintf(buf, "0x%x\n", codec->field);            \
+        return sysfs_emit(buf, "0x%x\n", codec->field);         \
 }
 
@@ -65 +65 @@
 {                                                               \
         struct hda_codec *codec = dev_get_drvdata(dev);         \
-        return sprintf(buf, "%s\n",                             \
-                       codec->field ? codec->field : "");       \
+        return sysfs_emit(buf, "%s\n",                          \
+                          codec->field ? codec->field : "");    \
 }
 
@@ -86 +86 @@
         mutex_lock(&codec->user_mutex);
         snd_array_for_each(list, i, pin) {
-                len += sprintf(buf + len, "0x%02x 0x%08x\n",
-                               pin->nid, pin->cfg);
+                len += sysfs_emit_at(buf, len, "0x%02x 0x%08x\n",
+                                     pin->nid, pin->cfg);
         }
         mutex_unlock(&codec->user_mutex);
@@ -223 +223 @@
         mutex_lock(&codec->user_mutex);
         snd_array_for_each(&codec->init_verbs, i, v) {
-                len += scnprintf(buf + len, PAGE_SIZE - len,
-                                "0x%02x 0x%03x 0x%04x\n",
-                                v->nid, v->verb, v->param);
+                len += sysfs_emit_at(buf, len, "0x%02x 0x%03x 0x%04x\n",
+                                     v->nid, v->verb, v->param);
         }
         mutex_unlock(&codec->user_mutex);
@@ -273 +272 @@
         mutex_lock(&codec->user_mutex);
         snd_array_for_each(&codec->hints, i, hint) {
-                len += scnprintf(buf + len, PAGE_SIZE - len,
-                                "%s = %s\n", hint->key, hint->val);
+                len += sysfs_emit_at(buf, len, "%s = %s\n",
+                                     hint->key, hint->val);
         }
         mutex_unlock(&codec->user_mutex);

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_hdmi.c

@@ -1291 +1291 @@
         per_pin = get_pin(spec, pin_idx);
         per_pin->cvt_nid = per_cvt->cvt_nid;
+        per_pin->silent_stream = false;
         hinfo->nid = per_cvt->cvt_nid;
 

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/patch_realtek.c

@@ -3755 +3755 @@
         snd_hda_apply_fixup(codec, HDA_FIXUP_ACT_PROBE);
 
+        for (i = 0; i < HDA_MAX_COMPONENTS; i++)
+                if (spec->comps[i].resume_hook)
+                        spec->comps[i].resume_hook(spec->comps[i].dev);
+
         return 0;
 
@@ -4676 +4680 @@
 {
         //NOT_USED struct alc_spec *spec = codec->spec;
+        int i;
 
 #ifndef TARGET_OS2
         if (spec->has_alc5505_dsp)
                 alc5505_dsp_suspend(codec);
+
+        for (i = 0; i < HDA_MAX_COMPONENTS; i++)
+                if (spec->comps[i].suspend_hook)
+                        spec->comps[i].suspend_hook(spec->comps[i].dev);
 #endif
         return alc_suspend(codec);
@@ -4687 +4696 @@
 {
         struct alc_spec *spec = codec->spec;
+        int i;
 
         if (spec->codec_variant == ALC269_TYPE_ALC269VB)
@@ -7354 +7364 @@
         struct hda_codec *cdc = dev_to_hda_codec(dev);
         struct alc_spec *spec = cdc->spec;
-
-        return component_bind_all(dev, spec->comps);
+        int ret, i;
+
+        ret = component_bind_all(dev, spec->comps);
+        if (ret)
+                return ret;
+
+        if (snd_hdac_is_power_on(&cdc->core)) {
+                codec_dbg(cdc, "Resuming after bind.\n");
+                for (i = 0; i < HDA_MAX_COMPONENTS; i++)
+                        if (spec->comps[i].resume_hook)
+                                spec->comps[i].resume_hook(spec->comps[i].dev);
+        }
+
+        return 0;
 }
 
@@ -7398 +7420 @@
                         if (!name)
                                 return;
+                        spec->comps[i].codec = cdc;
                         component_match_add(dev, &spec->match, component_compare_dev_name, name);
                 }
@@ -7428 +7451 @@
 {
         cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0100", 2);
+}
+
+static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
+                                                 int action)
+{
+        cs35l41_generic_fixup(cdc, action, "i2c", "CLSA0101", 2);
 }
 
@@ -7808 +7837 @@
         ALC285_FIXUP_HP_SPEAKERS_MICMUTE_LED,
         ALC295_FIXUP_FRAMEWORK_LAPTOP_MIC_NO_PRESENCE,
+        ALC287_FIXUP_LEGION_16ITHG6,
         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK,
         ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN,
@@ -10008 +10038 @@
                 .chained = true,
                 .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
+        },
+        [ALC287_FIXUP_LEGION_16ITHG6] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc287_fixup_legion_16ithg6_speakers,
         },
         [ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK] = {
@@ -10559 +10593 @@
         SND_PCI_QUIRK(0x17aa, 0x3852, "Lenovo Yoga 7 14ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
         SND_PCI_QUIRK(0x17aa, 0x3853, "Lenovo Yoga 7 15ITL5", ALC287_FIXUP_YOGA7_14ITL_SPEAKERS),
+        SND_PCI_QUIRK(0x17aa, 0x3855, "Legion 7 16ITHG6", ALC287_FIXUP_LEGION_16ITHG6),
+        SND_PCI_QUIRK(0x17aa, 0x3869, "Lenovo Yoga7 14IAL7", ALC287_FIXUP_YOGA9_14IAP7_BASS_SPK_PIN),
         SND_PCI_QUIRK(0x17aa, 0x3902, "Lenovo E50-80", ALC269_FIXUP_DMIC_THINKPAD_ACPI),
         SND_PCI_QUIRK(0x17aa, 0x3977, "IdeaPad S210", ALC283_FIXUP_INT_MIC),

GPL/branches/uniaud32-exp/include/linux/pm.h

@@ -247 +247 @@
         struct list_head        entry;
         enum rpm_status         runtime_status;
+        unsigned int            runtime_auto:1;
 };
 

GPL/branches/uniaud32-exp/lib32/misc.c

@@ -40 +40 @@
 #include <linux/firmware.h>
 #include <linux/ctype.h>
+#include <linux/math64.h>
 #include <dbgos2.h>
 
@@ -823 +824 @@
 }
 EXPORT_SYMBOL(sysfs_streq);
+
+u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder)
+{
+        u32 high = divisor >> 32;
+        u64 quot;
+
+        if (high == 0) {
+                u32 rem32;
+                quot = div_u64_rem(dividend, divisor, &rem32);
+                *remainder = rem32;
+        } else {
+                int n = fls(high);
+                quot = div_u64(dividend >> n, divisor >> n);
+
+                if (quot != 0)
+                        quot--;
+
+                *remainder = dividend - quot * divisor;
+                if (*remainder >= divisor) {
+                        quot++;
+                        *remainder -= divisor;
+                }
+        }
+
+        return quot;
+}
+
+/**
+ * memset32() - Fill a memory area with a uint32_t
+ * @s: Pointer to the start of the area.
+ * @v: The value to fill the area with
+ * @count: The number of values to store
+ *
+ * Differs from memset() in that it fills with a uint32_t instead
+ * of a byte.  Remember that @count is the number of uint32_ts to
+ * store, not the number of bytes.
+ */
+void *memset32(uint32_t *s, uint32_t v, size_t count)
+{
+        uint32_t *xs = s;
+
+        while (count--)
+                *xs++ = v;
+        return s;
+}
+EXPORT_SYMBOL(memset32);
+
+/**
+ *      sysfs_emit - scnprintf equivalent, aware of PAGE_SIZE buffer.
+ *      @buf:   start of PAGE_SIZE buffer.
+ *      @fmt:   format
+ *      @...:   optional arguments to @format
+ *
+ *
+ * Returns number of characters written to @buf.
+ */
+int sysfs_emit(char *buf, const char *fmt, ...)
+{
+        va_list args;
+        int len;
+
+#ifdef NOT_USED
+        if (WARN(!buf || offset_in_page(buf),
+                 "invalid sysfs_emit: buf:%p\n", buf))
+                return 0;
+#endif
+
+        va_start(args, fmt);
+        len = vscnprintf(buf, PAGE_SIZE, fmt, args);
+        va_end(args);
+
+        return len;
+}
+EXPORT_SYMBOL_GPL(sysfs_emit);
+
+/**
+ *      sysfs_emit_at - scnprintf equivalent, aware of PAGE_SIZE buffer.
+ *      @buf:   start of PAGE_SIZE buffer.
+ *      @at:    offset in @buf to start write in bytes
+ *              @at must be >= 0 && < PAGE_SIZE
+ *      @fmt:   format
+ *      @...:   optional arguments to @fmt
+ *
+ *
+ * Returns number of characters written starting at &@buf[@at].
+ */
+int sysfs_emit_at(char *buf, int at, const char *fmt, ...)
+{
+        va_list args;
+        int len;
+
+#ifdef NOT_USED
+        if (WARN(!buf || offset_in_page(buf) || at < 0 || at >= PAGE_SIZE,
+                 "invalid sysfs_emit_at: buf:%p at:%d\n", buf, at))
+                return 0;
+#endif
+
+        va_start(args, fmt);
+        len = vscnprintf(buf + at, PAGE_SIZE - at, fmt, args);
+        va_end(args);
+
+        return len;
+}
+EXPORT_SYMBOL_GPL(sysfs_emit_at);

GPL/branches/uniaud32-exp/lib32/vsprintf.c

@@ -32 +32 @@
 
 #include <stdarg.h>
-
+#include <linux/kernel.h>
 
 
@@ -366 +366 @@
 }
 
+/**
+ * vscnprintf - Format a string and place it in a buffer
+ * @buf: The buffer to place the result into
+ * @size: The size of the buffer, including the trailing null space
+ * @fmt: The format string to use
+ * @args: Arguments for the format string
+ *
+ * The return value is the number of characters which have been written into
+ * the @buf not including the trailing '\0'. If @size is == 0 the function
+ * returns 0.
+ *
+ * If you're not already dealing with a va_list consider using scnprintf().
+ *
+ * See the vsnprintf() documentation for format string extensions over C99.
+ */
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+        int i;
+
+        if (unlikely(!size))
+                return 0;
+
+        i = vsnprintf(buf, size, fmt, args);
+
+        if (likely(i < size))
+                return i;
+
+        return size - 1;
+}