Changeset 767

Timestamp:

Apr 13, 2025, 3:27:12 AM (8 days ago)

Author:

Paul Smedley

Message:

Get it compiling & linking

Location:

GPL/branches/uniaud32-exp

Files:

• alsa-kernel/core/control.c (modified) (59 diffs)
• alsa-kernel/core/hwdep.c (modified) (10 diffs)
• alsa-kernel/core/info.c (modified) (19 diffs)
• alsa-kernel/core/info_oss.c (modified) (4 diffs)
• alsa-kernel/core/init.c (modified) (24 diffs)
• alsa-kernel/core/oss/pcm_oss.c (modified) (10 diffs)
• alsa-kernel/core/pcm.c (modified) (20 diffs)
• alsa-kernel/core/pcm_lib.c (modified) (3 diffs)
• alsa-kernel/core/pcm_memory.c (modified) (5 diffs)
• alsa-kernel/core/pcm_native.c (modified) (45 diffs)
• alsa-kernel/core/rawmidi.c (modified) (38 diffs)
• alsa-kernel/core/seq/seq_fifo.c (modified) (10 diffs)
• alsa-kernel/core/seq/seq_memory.c (modified) (7 diffs)
• alsa-kernel/core/seq/seq_midi.c (modified) (6 diffs)
• alsa-kernel/core/seq/seq_midi_event.c (modified) (5 diffs)
• alsa-kernel/core/seq/seq_ports.c (modified) (20 diffs)
• alsa-kernel/core/seq/seq_prioq.c (modified) (11 diffs)
• alsa-kernel/core/seq/seq_queue.c (modified) (13 diffs)
• alsa-kernel/core/seq/seq_timer.c (modified) (24 diffs)
• alsa-kernel/core/sound.c (modified) (10 diffs)
• alsa-kernel/core/sound_oss.c (modified) (9 diffs)
• alsa-kernel/core/timer.c (modified) (66 diffs)
• alsa-kernel/hda/hdac_stream.c (modified) (2 diffs)
• alsa-kernel/include/sound/control.h (modified) (1 diff)
• alsa-kernel/include/sound/hdaudio.h (modified) (1 diff)
• alsa-kernel/include/sound/pcm.h (modified) (2 diffs)
• alsa-kernel/include/uapi/sound/asound.h (modified) (1 diff)
• alsa-kernel/pci/ac97/ac97_codec.c (modified) (2 diffs)
• alsa-kernel/pci/hda/Makefile (modified) (1 diff)
• alsa-kernel/pci/hda/hda_component2.h (modified) (2 diffs)
• alsa-kernel/pci/hda/patch_cmedia.c (modified) (4 diffs)
• alsa-kernel/pci/hda/patch_realtek.c (modified) (29 diffs)
• alsa-kernel/pci/maestro3.c (modified) (2 diffs)
• include/linux/compiler.h (modified) (1 diff)
• include/linux/device.h (modified) (1 diff)
• include/linux/export.h (modified) (1 diff)
• include/linux/kernel.h (modified) (1 diff)
• include/linux/module.h (modified) (1 diff)
• include/linux/pci_ids.h (modified) (7 diffs)
• include/linux/pm.h (modified) (2 diffs)
• include/linux/unaligned.h (moved) (moved from GPL/branches/uniaud32-exp/include/asm/unaligned.h )
• lib32/Makefile (modified) (1 diff)
• lib32/regcache.c (modified) (1 diff)
• lib32/regmap.c (modified) (1 diff)
• uniaud.inc (modified) (1 diff)

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

@@ -47 +47 @@
 static int snd_ctl_open(struct inode *inode, struct file *file)
 {
+        unsigned long flags;
         struct snd_card *card;
         struct snd_ctl_file *ctl;
@@ -82 +83 @@
         ctl->pid = get_pid(task_pid(current));
         file->private_data = ctl;
-        scoped_guard(write_lock_irqsave, &card->controls_rwlock)
+        write_lock_irqsave(&card->controls_rwlock, flags);
         list_add_tail(&ctl->list, &card->ctl_files);
+        write_unlock_irqrestore(&card->controls_rwlock, flags);
         snd_card_unref(card);
         return 0;
@@ -99 +101 @@
 static void snd_ctl_empty_read_queue(struct snd_ctl_file * ctl)
 {
+        unsigned long flags;
         struct snd_kctl_event *cread;
 
-        guard(spinlock_irqsave)(&ctl->read_lock);
+        spin_lock_irqsave(&ctl->read_lock, flags);
         while (!list_empty(&ctl->events)) {
                 cread = snd_kctl_event(ctl->events.next);
@@ -107 +110 @@
                 kfree(cread);
         }
+        spin_unlock_irqrestore(&ctl->read_lock, flags);
 }
 
 static int snd_ctl_release(struct inode *inode, struct file *file)
 {
+        unsigned long flags;
         struct snd_card *card;
         struct snd_ctl_file *ctl;
@@ -120 +125 @@
         card = ctl->card;
 
-        scoped_guard(write_lock_irqsave, &card->controls_rwlock)
+        write_lock_irqsave(&card->controls_rwlock, flags);
         list_del(&ctl->list);
-
-        scoped_guard(rwsem_write, &card->controls_rwsem) {
+        write_unlock_irqrestore(&card->controls_rwlock, flags);
+        down_write(&card->controls_rwsem);
         list_for_each_entry(control, &card->controls, list, struct snd_kcontrol)
                 for (idx = 0; idx < control->count; idx++)
                         if (control->vd[idx].owner == ctl)
                                 control->vd[idx].owner = NULL;
-        }
+        up_write(&card->controls_rwsem);
 
         snd_fasync_free(ctl->fasync);
@@ -152 +157 @@
                     struct snd_ctl_elem_id *id)
 {
+        unsigned long flags;
         struct snd_ctl_file *ctl;
         struct snd_kctl_event *ev;
@@ -160 +166 @@
                 return;
 
-        guard(read_lock_irqsave)(&card->controls_rwlock);
+        read_lock_irqsave(&card->controls_rwlock, flags);
 //#if (IS_ENABLED(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS))
 #if defined(CONFIG_SND_MIXER_OSS)
@@ -168 +174 @@
                 if (!ctl->subscribed)
                         continue;
-                scoped_guard(spinlock, &ctl->read_lock) {
+                spin_lock(&ctl->read_lock);
                 list_for_each_entry(ev, &ctl->events, list, struct snd_kctl_event) {
                         if (ev->id.numid == id->numid) {
@@ -185 +191 @@
         _found:
                 wake_up(&ctl->change_sleep);
-                }
+                spin_unlock(&ctl->read_lock);
                 snd_kill_fasync(ctl->fasync, SIGIO, POLL_IN);
         }
+        read_unlock_irqrestore(&card->controls_rwlock, flags);
 }
 EXPORT_SYMBOL(snd_ctl_notify);
@@ -210 +217 @@
         id.numid += ioff;
         snd_ctl_notify(card, mask, &id);
-        guard(rwsem_read)(&snd_ctl_layer_rwsem);
+        down_read(&snd_ctl_layer_rwsem);
         for (lops = snd_ctl_layer; lops; lops = lops->next)
                 lops->lnotify(card, mask, kctl, ioff);
+        up_read(&snd_ctl_layer_rwsem);
 }
 EXPORT_SYMBOL(snd_ctl_notify_one);
@@ -505 +513 @@
                 return -ENOMEM;
 
-        scoped_guard(write_lock_irq, &card->controls_rwlock) {
         list_add_tail(&kcontrol->list, &card->controls);
         card->controls_count += kcontrol->count;
         kcontrol->id.numid = card->last_numid + 1;
         card->last_numid += kcontrol->count;
-        }
 
         add_hash_entries(card, kcontrol);
@@ -531 +537 @@
                 goto error;
 
-        scoped_guard(rwsem_write, &card->controls_rwsem)
+        down_write(&card->controls_rwsem);
         err = __snd_ctl_add_replace(card, kcontrol, mode);
+        up_write(&card->controls_rwsem);
 
         if (err < 0)
@@ -595 +602 @@
         if (snd_BUG_ON(!card || !kcontrol))
                 return -EINVAL;
+        list_del(&kcontrol->list);
 
         if (remove_hash)
                 remove_hash_entries(card, kcontrol);
 
-        scoped_guard(write_lock_irq, &card->controls_rwlock) {
-                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);
@@ -631 +635 @@
 int snd_ctl_remove(struct snd_card *card, struct snd_kcontrol *kcontrol)
 {
-        if (!kcontrol)
-                return 0;
-        guard(rwsem_write)(&card->controls_rwsem);
-        return snd_ctl_remove_locked(card, kcontrol);
+        int ret;
+
+        down_write(&card->controls_rwsem);
+        ret = snd_ctl_remove_locked(card, kcontrol);
+        up_write(&card->controls_rwsem);
+        return ret;
 }
 EXPORT_SYMBOL(snd_ctl_remove);
@@ -651 +657 @@
 {
         struct snd_kcontrol *kctl;
-
-        guard(rwsem_write)(&card->controls_rwsem);
+        int ret;
+
+        down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, id);
-        if (kctl == NULL)
+        if (kctl == NULL) {
+                up_write(&card->controls_rwsem);
                 return -ENOENT;
-        return snd_ctl_remove_locked(card, kctl);
+        }
+        ret = snd_ctl_remove_locked(card, kctl);
+        up_write(&card->controls_rwsem);
+        return ret;
 }
 EXPORT_SYMBOL(snd_ctl_remove_id);
@@ -675 +686 @@
         struct snd_card *card = file->card;
         struct snd_kcontrol *kctl;
-        int idx;
-
-        guard(rwsem_write)(&card->controls_rwsem);
+        int idx, ret;
+
+        down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, id);
-        if (kctl == NULL)
-                return -ENOENT;
-        if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER))
-                return -EINVAL;
+        if (kctl == NULL) {
+                ret = -ENOENT;
+                goto error;
+        }
+        if (!(kctl->vd[0].access & SNDRV_CTL_ELEM_ACCESS_USER)) {
+                ret = -EINVAL;
+                goto error;
+        }
         for (idx = 0; idx < kctl->count; idx++)
-                if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file)
-                        return -EBUSY;
-        return snd_ctl_remove_locked(card, kctl);
+                if (kctl->vd[idx].owner != NULL && kctl->vd[idx].owner != file) {
+                        ret = -EBUSY;
+                        goto error;
+                }
+        ret = snd_ctl_remove_locked(card, kctl);
+error:
+        up_write(&card->controls_rwsem);
+        return ret;
 }
 
@@ -763 +783 @@
         int saved_numid;
 
-        guard(rwsem_write)(&card->controls_rwsem);
+        down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, src_id);
-        if (kctl == NULL)
+        if (kctl == NULL) {
+                up_write(&card->controls_rwsem);
                 return -ENOENT;
+        }
         saved_numid = kctl->id.numid;
         remove_hash_entries(card, kctl);
@@ -772 +794 @@
         kctl->id.numid = saved_numid;
         add_hash_entries(card, kctl);
+        up_write(&card->controls_rwsem);
         return 0;
 }
@@ -789 +812 @@
                     const char *name)
 {
-        guard(rwsem_write)(&card->controls_rwsem);
+        down_write(&card->controls_rwsem);
         remove_hash_entries(card, kctl);
 
@@ -797 +820 @@
 
         add_hash_entries(card, kctl);
+        up_write(&card->controls_rwsem);
 }
 EXPORT_SYMBOL(snd_ctl_rename);
@@ -806 +830 @@
         struct snd_kcontrol *kctl;
 
-        guard(read_lock_irqsave)(&card->controls_rwlock);
         list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol) {
                 if (kctl->id.numid <= numid && kctl->id.numid + kctl->count > numid)
@@ -869 +892 @@
 #endif
         /* no matching in hash table - try all as the last resort */
-        guard(read_lock_irqsave)(&card->controls_rwlock);
         list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol)
                 if (elem_id_matches(kctl, id))
@@ -885 +907 @@
         if (! info)
                 return -ENOMEM;
-        scoped_guard(rwsem_read, &snd_ioctl_rwsem) {
+        down_read(&snd_ioctl_rwsem);
         info->card = card->number;
         strscpy(info->id, card->id, sizeof(info->id));
@@ -893 +915 @@
         strscpy(info->mixername, card->mixername, sizeof(info->mixername));
         strscpy(info->components, card->components, sizeof(info->components));
-        }
-        if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info)))
+        up_read(&snd_ioctl_rwsem);
+        if (copy_to_user(arg, info, sizeof(struct snd_ctl_card_info))) {
+                kfree(info);
                 return -EFAULT;
+        }
+        kfree(info);
         return 0;
 }
@@ -905 +930 @@
         struct snd_ctl_elem_id id;
         unsigned int offset, space, jidx;
+        int err = 0;
 
         offset = list->offset;
         space = list->space;
 
-        guard(rwsem_read)(&card->controls_rwsem);
+        down_read(&card->controls_rwsem);
         list->count = card->controls_count;
         list->used = 0;
-        if (!space)
-                return 0;
+        if (space > 0) {
                 list_for_each_entry(kctl, &card->controls, list, struct snd_kcontrol) {
                         if (offset >= kctl->count) {
@@ -921 +946 @@
                         for (jidx = offset; jidx < kctl->count; jidx++) {
                                 snd_ctl_build_ioff(&id, kctl, jidx);
-                        if (copy_to_user(list->pids + list->used, &id, sizeof(id)))
-                                return -EFAULT;
+                                if (copy_to_user(list->pids + list->used, &id,
+                                                 sizeof(id))) {
+                                        err = -EFAULT;
+                                        goto out;
+                                }
                                 list->used++;
                                 if (!--space)
-                                return 0;
+                                        goto out;
                         }
                         offset = 0;
+                        }
                 }
-        return 0;
+ out:
+        up_read(&card->controls_rwsem);
+        return err;
 }
 
@@ -1175 +1206 @@
         struct snd_kcontrol *kctl;
 
-        guard(rwsem_read)(&card->controls_rwsem);
+        int result;
+
+        down_read(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &info->id);
-        if (!kctl)
-                return -ENOENT;
-        return __snd_ctl_elem_info(card, kctl, info, ctl);
+        if (kctl == NULL)
+                result = -ENOENT;
+        else
+                result = __snd_ctl_elem_info(card, kctl, info, ctl);
+        up_read(&card->controls_rwsem);
+        return result;
 }
 
@@ -1216 +1252 @@
         int ret;
 
-        guard(rwsem_read)(&card->controls_rwsem);
+        down_read(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &control->id);
-        if (!kctl)
-                return -ENOENT;
+        if (kctl == NULL) {
+                ret = -ENOENT;
+                goto unlock;
+        }
 
         index_offset = snd_ctl_get_ioff(kctl, &control->id);
         vd = &kctl->vd[index_offset];
-        if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_READ) || !kctl->get)
-                return -EPERM;
+        if (!(vd->access & SNDRV_CTL_ELEM_ACCESS_READ) || kctl->get == NULL) {
+                ret = -EPERM;
+                goto unlock;
+        }
 
         snd_ctl_build_ioff(&control->id, kctl, index_offset);
@@ -1234 +1274 @@
         ret = __snd_ctl_elem_info(card, kctl, &info, NULL);
         if (ret < 0)
-                return ret;
+                goto unlock;
 #endif
 
         if (!snd_ctl_skip_validation(&info))
                 fill_remaining_elem_value(control, &info, pattern);
-                ret = kctl->get(kctl, control);
+        ret = kctl->get(kctl, control);
         if (ret < 0)
-                return ret;
+                goto unlock;
         if (!snd_ctl_skip_validation(&info) &&
             sanity_check_elem_value(card, control, &info, pattern) < 0) {
@@ -1249 +1289 @@
                         control->id.subdevice, control->id.name,
                         control->id.index);
-                return -EINVAL;
-        }
-        return 0;
+                ret = -EINVAL;
+                goto unlock;
+        }
+unlock:
+        up_read(&card->controls_rwsem);
+        return ret;
 }
 
@@ -1302 +1345 @@
         snd_ctl_build_ioff(&control->id, kctl, index_offset);
         /* validate input values */
+#ifndef TARGET_OS2
         if (IS_ENABLED(CONFIG_SND_CTL_INPUT_VALIDATION)) {
                 struct snd_ctl_elem_info info;
@@ -1312 +1356 @@
                                                            false);
         }
+#endif
         if (!result)
                 result = kctl->put(kctl, control);
@@ -1362 +1407 @@
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_volatile *vd;
+        int result;
 
         if (copy_from_user(&id, _id, sizeof(id)))
                 return -EFAULT;
-        guard(rwsem_write)(&card->controls_rwsem);
+        down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &id);
-        if (!kctl)
-                return -ENOENT;
+        if (kctl == NULL) {
+                result = -ENOENT;
+        } else {
                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
-        if (vd->owner)
-                return -EBUSY;
+                if (vd->owner != NULL)
+                        result = -EBUSY;
+                else {
                         vd->owner = file;
-        return 0;
+                        result = 0;
+                }
+        }
+        up_write(&card->controls_rwsem);
+        return result;
 }
 
@@ -1383 +1435 @@
         struct snd_kcontrol *kctl;
         struct snd_kcontrol_volatile *vd;
+        int result;
 
         if (copy_from_user(&id, _id, sizeof(id)))
                 return -EFAULT;
-        guard(rwsem_write)(&card->controls_rwsem);
+        down_write(&card->controls_rwsem);
         kctl = snd_ctl_find_id(card, &id);
-        if (!kctl)
-                return -ENOENT;
+        if (kctl == NULL) {
+                result = -ENOENT;
+        } else {
                 vd = &kctl->vd[snd_ctl_get_ioff(kctl, &id)];
-        if (!vd->owner)
-                return -EINVAL;
-        if (vd->owner != file)
-                return -EPERM;
+                if (vd->owner == NULL)
+                        result = -EINVAL;
+                else if (vd->owner != file)
+                        result = -EPERM;
+                else {
                         vd->owner = NULL;
-        return 0;
+                        result = 0;
+                }
+        }
+        up_write(&card->controls_rwsem);
+        return result;
 }
 
@@ -1677 +1736 @@
         err = snd_ctl_check_elem_info(NULL, info);
         if (err < 0)
-                return err;
+                goto unlock;
         /* user-space control doesn't allow zero-size data */
         if (info->count < 1)
@@ -1684 +1743 @@
         alloc_size = compute_user_elem_size(private_size, count);
 
-        guard(rwsem_write)(&card->controls_rwsem);
-        if (check_user_elem_overflow(card, alloc_size))
-                return -ENOMEM;
+        down_write(&card->controls_rwsem);
+        if (check_user_elem_overflow(card, alloc_size)) {
+                err = -ENOMEM;
+                goto unlock;
+        }
 
         /*
@@ -1696 +1757 @@
         err = snd_ctl_new(&kctl, count, access, file);
         if (err < 0)
-                return err;
+                goto unlock;
         memcpy(&kctl->id, &info->id, sizeof(kctl->id));
         ue = kzalloc(alloc_size, GFP_KERNEL);
         if (!ue) {
                 kfree(kctl);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto unlock;
         }
         kctl->private_data = ue;
@@ -1719 +1781 @@
                 if (err < 0) {
                         snd_ctl_free_one(kctl);
-                        return err;
+                        goto unlock;
                 }
         }
@@ -1739 +1801 @@
         if (err < 0) {
                 snd_ctl_free_one(kctl);
-                return err;
+                goto unlock;
         }
         offset = snd_ctl_get_ioff(kctl, &info->id);
@@ -1750 +1812 @@
          * which locks the element.
          */
-        return 0;
+ unlock:
+        up_write(&card->controls_rwsem);
+        return err;
 }
 
@@ -1951 +2015 @@
                 if (err < 0)
                         return err;
-                scoped_guard(rwsem_read, &card->controls_rwsem)
+                down_read(&ctl->card->controls_rwsem);
                 err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_READ);
+                up_read(&ctl->card->controls_rwsem);
                 snd_power_unref(card);
                 return err;
@@ -1959 +2024 @@
                 if (err < 0)
                         return err;
-                scoped_guard(rwsem_write, &card->controls_rwsem)
+                down_write(&ctl->card->controls_rwsem);
                 err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_WRITE);
+                up_write(&ctl->card->controls_rwsem);
+        case SNDRV_CTL_IOCTL_TLV_COMMAND:
                 snd_power_unref(card);
                 return err;
-        case SNDRV_CTL_IOCTL_TLV_COMMAND:
                 err = snd_power_ref_and_wait(card);
                 if (err < 0)
                         return err;
-                scoped_guard(rwsem_write, &card->controls_rwsem)
+                down_write(&ctl->card->controls_rwsem);
                 err = snd_ctl_tlv_ioctl(ctl, argp, SNDRV_CTL_TLV_OP_CMD);
+                up_write(&ctl->card->controls_rwsem);
                 snd_power_unref(card);
                 return err;
@@ -1976 +2043 @@
                 return put_user(SNDRV_CTL_POWER_D0, ip) ? -EFAULT : 0;
         }
-
-        guard(rwsem_read)(&snd_ioctl_rwsem);
+        down_read(&snd_ioctl_rwsem);
+
         list_for_each_entry(p, &snd_control_ioctls, list, struct snd_kctl_ioctl) {
                 err = p->fioctl(card, ctl, cmd, arg);
-                if (err != -ENOIOCTLCMD)
+                if (err != -ENOIOCTLCMD) {
+                        up_read(&snd_ioctl_rwsem);
                         return err;
-        }
+                }
+        }
+        up_read(&snd_ioctl_rwsem);
         dev_dbg(card->dev, "unknown ioctl = 0x%x\n", cmd);
         return -ENOTTY;
@@ -2074 +2144 @@
                 return -ENOMEM;
         pn->fioctl = fcn;
-        guard(rwsem_write)(&snd_ioctl_rwsem);
+        down_write(&snd_ioctl_rwsem);
         list_add_tail(&pn->list, lists);
+        up_write(&snd_ioctl_rwsem);
         return 0;
 }
@@ -2118 +2189 @@
         if (snd_BUG_ON(!fcn))
                 return -EINVAL;
-        guard(rwsem_write)(&snd_ioctl_rwsem);
+        down_write(&snd_ioctl_rwsem);
         list_for_each_entry(p, lists, list, struct snd_kctl_ioctl) {
                 if (p->fioctl == fcn) {
@@ -2127 +2198 @@
                 }
         }
+        up_write(&snd_ioctl_rwsem);
         snd_BUG();
         return -EINVAL;
@@ -2173 +2245 @@
         struct snd_ctl_file *kctl;
         int subdevice = -1;
-
-        guard(read_lock_irqsave)(&card->controls_rwlock);
+        unsigned long flags;
+ 
+        read_lock_irqsave(&card->controls_rwlock, flags);
         list_for_each_entry(kctl, &card->ctl_files, list, struct snd_ctl_file) {
                 if (kctl->pid == task_pid(current)) {
@@ -2182 +2255 @@
                 }
         }
+        read_unlock_irqrestore(&card->controls_rwlock, flags);
         return subdevice;
 }
@@ -2211 +2285 @@
         if (module_name == NULL)
                 return 0;
-        scoped_guard(rwsem_read, &snd_ctl_layer_rwsem) {
+        down_read(&snd_ctl_layer_rwsem);
         for (lops = snd_ctl_layer; lops; lops = lops->next)
                 if (strcmp(lops->module_name, module_name) == 0)
+                        break;
+        up_read(&snd_ctl_layer_rwsem);
+        if (lops)
                 return 0;
-        }
         return request_module(module_name);
 }
@@ -2232 +2308 @@
         int card_number;
 
-        scoped_guard(rwsem_write, &snd_ctl_layer_rwsem) {
+        down_write(&snd_ctl_layer_rwsem);
         lops->next = snd_ctl_layer;
         snd_ctl_layer = lops;
-        }
+        up_write(&snd_ctl_layer_rwsem);
         for (card_number = 0; card_number < SNDRV_CARDS; card_number++) {
                 card = snd_card_ref(card_number);
                 if (card) {
-                        scoped_guard(rwsem_read, &card->controls_rwsem)
+                        down_read(&card->controls_rwsem);
                         lops->lregister(card);
+                        up_read(&card->controls_rwsem);
                         snd_card_unref(card);
                 }
@@ -2259 +2336 @@
         struct snd_ctl_layer_ops *lops2, *prev_lops2;
 
-        guard(rwsem_write)(&snd_ctl_layer_rwsem);
+        down_write(&snd_ctl_layer_rwsem);
         for (lops2 = snd_ctl_layer, prev_lops2 = NULL; lops2; lops2 = lops2->next) {
                 if (lops2 == lops) {
@@ -2270 +2347 @@
                 prev_lops2 = lops2;
         }
+        up_write(&snd_ctl_layer_rwsem);
 }
 EXPORT_SYMBOL_GPL(snd_ctl_disconnect_layer);
@@ -2289 +2367 @@
 };
 
+#ifndef TARGET_OS2
 /* call lops under rwsems; called from snd_ctl_dev_*() below() */
 #define call_snd_ctl_lops(_card, _op)                               \
@@ -2298 +2377 @@
                         lops->_op(_card);                           \
         } while (0)
+#endif
 
 /*
@@ -2305 +2385 @@
 {
         struct snd_card *card = device->device_data;
+        struct snd_ctl_layer_ops *lops;
         int err;
 
@@ -2311 +2392 @@
         if (err < 0)
                 return err;
-        call_snd_ctl_lops(card, lregister);
+        down_read(&card->controls_rwsem);
+        down_read(&snd_ctl_layer_rwsem);
+        for (lops = snd_ctl_layer; lops; lops = lops->next)
+                lops->lregister(card);
+        up_read(&snd_ctl_layer_rwsem);
+        up_read(&card->controls_rwsem);
         return 0;
 }
@@ -2322 +2408 @@
         struct snd_card *card = device->device_data;
         struct snd_ctl_file *ctl;
-
-        scoped_guard(read_lock_irqsave, &card->controls_rwlock) {
+        struct snd_ctl_layer_ops *lops;
+        unsigned long flags;
+
+        read_lock_irqsave(&card->controls_rwlock, flags);
         list_for_each_entry(ctl, &card->ctl_files, list, struct snd_ctl_file) {
                 wake_up(&ctl->change_sleep);
                 snd_kill_fasync(ctl->fasync, SIGIO, POLL_ERR);
         }
-        }
-
-        call_snd_ctl_lops(card, ldisconnect);
+        read_unlock_irqrestore(&card->controls_rwlock, flags);
+
+        down_read(&card->controls_rwsem);
+        down_read(&snd_ctl_layer_rwsem);
+        for (lops = snd_ctl_layer; lops; lops = lops->next)
+                lops->ldisconnect(card);
+        up_read(&snd_ctl_layer_rwsem);
+        up_read(&card->controls_rwsem);
         return snd_unregister_device(card->ctl_dev);
 }
@@ -2342 +2435 @@
         struct snd_kcontrol *control;
 
-        scoped_guard(rwsem_write, &card->controls_rwsem) {
+        down_write(&card->controls_rwsem);
         while (!list_empty(&card->controls)) {
                 control = snd_kcontrol(card->controls.next);
@@ -2352 +2445 @@
         xa_destroy(&card->ctl_hash);
 #endif
-        }
+        up_write(&card->controls_rwsem);
         put_device(card->ctl_dev);
         return 0;

GPL/branches/uniaud32-exp/alsa-kernel/core/hwdep.c ¶

@@ -150 +150 @@
         struct module *mod = hw->card->module;
 
-        scoped_guard(mutex, &hw->open_mutex) {
+        mutex_lock(&hw->open_mutex);
         if (hw->ops.release)
                 err = hw->ops.release(hw, file);
         if (hw->used > 0)
                 hw->used--;
-        }
+        mutex_unlock(&hw->open_mutex);
         wake_up(&hw->open_wait);
 
@@ -273 +273 @@
                         if (get_user(device, (int __user *)arg))
                                 return -EFAULT;
-
-                        scoped_guard(mutex, &register_mutex) {
+                        mutex_lock(&register_mutex);
+
                         if (device < 0)
                                 device = 0;
@@ -289 +289 @@
                         if (device >= SNDRV_MINOR_HWDEPS)
                                 device = -1;
-                        }
+                        mutex_unlock(&register_mutex);
                         if (put_user(device, (int __user *)arg))
                                 return -EFAULT;
@@ -297 +297 @@
                 {
                         struct snd_hwdep_info __user *info = (struct snd_hwdep_info __user *)arg;
-                        int device;
+                        int device, err;
                         struct snd_hwdep *hwdep;
 
                         if (get_user(device, &info->device))
                                 return -EFAULT;
-                        scoped_guard(mutex, &register_mutex) {
+                        mutex_lock(&register_mutex);
                         hwdep = snd_hwdep_search(card, device);
-                                if (!hwdep)
-                                        return -ENXIO;
-                                return snd_hwdep_info(hwdep, info);
-                        }
-                        break;
+                        if (hwdep)
+                                err = snd_hwdep_info(hwdep, info);
+                        else
+                                err = -ENXIO;
+                        mutex_unlock(&register_mutex);
+                        return err;
                 }
         }
@@ -422 +423 @@
         int err;
 
-        guard(mutex)(&register_mutex);
-        if (snd_hwdep_search(card, hwdep->device))
+        mutex_lock(&register_mutex);
+        if (snd_hwdep_search(card, hwdep->device)) {
+                mutex_unlock(&register_mutex);
                 return -EBUSY;
+        }
         list_add_tail(&hwdep->list, &snd_hwdep_devices);
         err = snd_register_device(SNDRV_DEVICE_TYPE_HWDEP,
@@ -432 +435 @@
                 dev_err(hwdep->dev, "unable to register\n");
                 list_del(&hwdep->list);
+                mutex_unlock(&register_mutex);
                 return err;
         }
@@ -451 +455 @@
         }
 #endif
+        mutex_unlock(&register_mutex);
         return 0;
 }
@@ -460 +465 @@
         if (snd_BUG_ON(!hwdep))
                 return -ENXIO;
-        guard(mutex)(&register_mutex);
-        if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep)
+        mutex_lock(&register_mutex);
+        if (snd_hwdep_search(hwdep->card, hwdep->device) != hwdep) {
+                mutex_unlock(&register_mutex);
                 return -EINVAL;
-        guard(mutex)(&hwdep->open_mutex);
+        }
+        mutex_lock(&hwdep->open_mutex);
         wake_up(&hwdep->open_wait);
 #ifdef CONFIG_SND_OSSEMUL
@@ -471 +478 @@
         snd_unregister_device(hwdep->dev);
         list_del_init(&hwdep->list);
+        mutex_unlock(&hwdep->open_mutex);
+        mutex_unlock(&register_mutex);
         return 0;
 }
@@ -484 +493 @@
         struct snd_hwdep *hwdep;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         list_for_each_entry(hwdep, &snd_hwdep_devices, list, struct snd_hwdep)
                 snd_iprintf(buffer, "%02i-%02i: %s\n",
                             hwdep->card->number, hwdep->device, hwdep->name);
+        mutex_unlock(&register_mutex);
 }
 

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

@@ -107 +107 @@
         struct snd_info_private_data *data;
         struct snd_info_entry *entry;
-        loff_t size;
+        loff_t ret = -EINVAL, size;
 
         data = file->private_data;
         entry = data->entry;
-        guard(mutex)(&entry->access);
-        if (entry->c.ops->llseek)
-                return entry->c.ops->llseek(entry,
+        mutex_lock(&entry->access);
+        if (entry->c.ops->llseek) {
+                ret = entry->c.ops->llseek(entry,
                                            data->file_private_data,
                                            file, offset, orig);
+                goto out;
+        }
 
         size = entry->size;
@@ -126 +128 @@
         case SEEK_END:
                 if (!size)
-                        return -EINVAL;
+                        goto out;
                 offset += size;
                 break;
         default:
-                return -EINVAL;
+                goto out;
         }
         if (offset < 0)
-                return -EINVAL;
+                goto out;
         if (size && offset > size)
                 offset = size;
         file->f_pos = offset;
-        return offset;
+        ret = offset;
+ out:
+        mutex_unlock(&entry->access);
+        return ret;
 }
 
@@ -235 +240 @@
         int mode, err;
 
-        guard(mutex)(&info_mutex);
+        mutex_lock(&info_mutex);
         err = alloc_info_private(entry, &data);
         if (err < 0)
-                return err;
+                goto unlock;
 
         mode = file->f_flags & O_ACCMODE;
@@ -254 +259 @@
 
         file->private_data = data;
+        mutex_unlock(&info_mutex);
         return 0;
 
@@ -259 +265 @@
         kfree(data);
         module_put(entry->module);
+ unlock:
+        mutex_unlock(&info_mutex);
         return err;
 }
@@ -300 +308 @@
         loff_t pos;
         size_t next;
+        int err = 0;
 
         if (!entry->c.text.write)
@@ -310 +319 @@
         if (next > 16 * 1024)
                 return -EIO;
-        guard(mutex)(&entry->access);
+        mutex_lock(&entry->access);
         buf = data->wbuffer;
         if (!buf) {
                 data->wbuffer = buf = kzalloc(sizeof(*buf), GFP_KERNEL);
-                if (!buf)
-                        return -ENOMEM;
+                if (!buf) {
+                        err = -ENOMEM;
+                        goto error;
+                }
         }
         if (next > buf->len) {
@@ -325 +336 @@
                 buf->len = PAGE_ALIGN(next);
         }
-        if (copy_from_user(buf->buffer + pos, buffer, count))
-                return -EFAULT;
+        if (copy_from_user(buf->buffer + pos, buffer, count)) {
+                err = -EFAULT;
+                goto error;
+        }
         buf->size = next;
+ error:
+        mutex_unlock(&entry->access);
+        if (err < 0)
+                return err;
         *offset = next;
         return count;
@@ -352 +369 @@
         int err;
 
-        guard(mutex)(&info_mutex);
+        mutex_lock(&info_mutex);
         err = alloc_info_private(entry, &data);
         if (err < 0)
-                return err;
+                goto unlock;
 
         data->rbuffer = kzalloc(sizeof(*data->rbuffer), GFP_KERNEL);
@@ -369 +386 @@
         if (err < 0)
                 goto error;
+        mutex_unlock(&info_mutex);
         return 0;
 
@@ -375 +393 @@
         kfree(data);
         module_put(entry->module);
+ unlock:
+        mutex_unlock(&info_mutex);
         return err;
 }
@@ -530 +550 @@
 void snd_info_card_id_change(struct snd_card *card)
 {
-        guard(mutex)(&info_mutex);
+        mutex_lock(&info_mutex);
         if (card->proc_root_link) {
                 proc_remove(card->proc_root_link);
@@ -539 +559 @@
                                                     snd_proc_root->p,
                                                     card->proc_root->name);
+        mutex_unlock(&info_mutex);
 }
 
@@ -554 +575 @@
                 proc_remove(card->proc_root->p);
 
-        guard(mutex)(&info_mutex);
+        mutex_lock(&info_mutex);
         if (card->proc_root)
                 snd_info_clear_entries(card->proc_root);
         card->proc_root_link = NULL;
         card->proc_root = NULL;
+        mutex_unlock(&info_mutex);
 }
 
@@ -682 +704 @@
         entry->module = module;
         if (parent) {
-                guard(mutex)(&parent->access);
+                mutex_lock(&parent->access);
                 list_add_tail(&entry->list, &parent->children);
+                mutex_unlock(&parent->access);
         }
         return entry;
@@ -753 +776 @@
         if (entry->p) {
                 proc_remove(entry->p);
-                guard(mutex)(&info_mutex);
+                mutex_lock(&info_mutex);
                 snd_info_clear_entries(entry);
+                mutex_unlock(&info_mutex);
         }
 
@@ -763 +787 @@
         p = entry->parent;
         if (p) {
-                guard(mutex)(&p->access);
+                mutex_lock(&p->access);
                 list_del(&entry->list);
+                mutex_unlock(&p->access);
         }
         kfree(entry->name);
@@ -780 +805 @@
                 return -ENXIO;
         root = entry->parent == NULL ? snd_proc_root->p : entry->parent->p;
-        guard(mutex)(&info_mutex);
+        mutex_lock(&info_mutex);
         if (entry->p || !root)
-                return 0;
+                goto unlock;
 #ifndef TARGET_OS2
         if (S_ISDIR(entry->mode)) {
@@ -802 +827 @@
 #endif
         entry->p = p;
+ unlock:
+        mutex_unlock(&info_mutex);
         return 0;
 }

GPL/branches/uniaud32-exp/alsa-kernel/core/info_oss.c ¶

@@ -30 +30 @@
         if (snd_BUG_ON(num < 0 || num >= SNDRV_CARDS))
                 return -ENXIO;
-        guard(mutex)(&strings);
+        mutex_lock(&strings);
         if (string == NULL) {
                 x = snd_sndstat_strings[num][dev];
@@ -37 +37 @@
         } else {
                 x = kstrdup(string, GFP_KERNEL);
-                if (x == NULL)
+                if (x == NULL) {
+                        mutex_unlock(&strings);
                         return -ENOMEM;
                 }
+        }
         snd_sndstat_strings[num][dev] = x;
+        mutex_unlock(&strings);
         return 0;
 }
@@ -51 +54 @@
 
         snd_iprintf(buf, "\n%s:", id);
-        guard(mutex)(&strings);
+        mutex_lock(&strings);
         for (idx = 0; idx < SNDRV_CARDS; idx++) {
                 str = snd_sndstat_strings[idx][dev];
@@ -62 +65 @@
                 }
         }
+        mutex_unlock(&strings);
         if (ok < 0)
                 snd_iprintf(buf, " NOT ENABLED IN CONFIG\n");

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

@@ -289 +289 @@
                 strscpy(card->id, xid, sizeof(card->id));
         err = 0;
-        scoped_guard(mutex, &snd_card_mutex) {
+        mutex_lock(&snd_card_mutex);
         if (idx < 0) /* first check the matching module-name slot */
                 idx = get_slot_from_bitmask(idx, module_slot_match, module);
@@ -301 +301 @@
         } else if (idx >= SNDRV_CARDS)
                 err = -ENODEV;
-                if (!err) {
-                        set_bit(idx, snd_cards_lock);           /* lock it */
-                        if (idx >= snd_ecards_limit)
-                                snd_ecards_limit = idx + 1; /* increase the limit */
-                }
-        }
         if (err < 0) {
+                mutex_unlock(&snd_card_mutex);
                 dev_err(parent, "cannot find the slot for index %d (range 0-%i), error: %d\n",
                          idx, snd_ecards_limit - 1, err);
@@ -314 +309 @@
                 return err;
         }
+        set_bit(idx, snd_cards_lock);           /* lock it */
+        if (idx >= snd_ecards_limit)
+                snd_ecards_limit = idx + 1; /* increase the limit */
+        mutex_unlock(&snd_card_mutex);
         card->dev = parent;
         card->number = idx;
@@ -390 +389 @@
         struct snd_card *card;
 
-        guard(mutex)(&snd_card_mutex);
+        mutex_lock(&snd_card_mutex);
         card = snd_cards[idx];
         if (card)
                 get_device(&card->card_dev);
+        mutex_unlock(&snd_card_mutex);
         return card;
 }
@@ -401 +401 @@
 int snd_card_locked(int card)
 {
-        guard(mutex)(&snd_card_mutex);
-        return test_bit(card, snd_cards_lock);
+        int locked;
+
+        mutex_lock(&snd_card_mutex);
+        locked = test_bit(card, snd_cards_lock);
+        mutex_unlock(&snd_card_mutex);
+        return locked;
 }
 
@@ -426 +430 @@
         struct snd_monitor_file *df = NULL, *_df;
 
-        scoped_guard(spinlock, &shutdown_lock) {
+        spin_lock(&shutdown_lock);
         list_for_each_entry(_df, &shutdown_files, shutdown_list, struct snd_monitor_file) {
                 if (_df->file == file) {
@@ -434 +438 @@
                 }
         }
-        }
+        spin_unlock(&shutdown_lock);
 
         if (likely(df)) {
@@ -503 +507 @@
                 return;
 
-        scoped_guard(spinlock, &card->files_lock) {
-                if (card->shutdown)
+        spin_lock(&card->files_lock);
+        if (card->shutdown) {
+                spin_unlock(&card->files_lock);
                 return;
+        }
         card->shutdown = 1;
 
@@ -514 +520 @@
                 mfile->disconnected_f_op = mfile->file->f_op;
 
-                        scoped_guard(spinlock, &shutdown_lock)
+                spin_lock(&shutdown_lock);
                 list_add(&mfile->shutdown_list, &shutdown_files);
+                spin_unlock(&shutdown_lock);
 
                 mfile->file->f_op = &snd_shutdown_f_ops;
                 //DAZ this does nothing. fops_get(mfile->file->f_op);
         }
-        }
+        spin_unlock(&card->files_lock); 
 
 #ifdef CONFIG_PM
@@ -556 +563 @@
 
         /* disable fops (user space) operations for ALSA API */
-        scoped_guard(mutex, &snd_card_mutex) {
+        mutex_lock(&snd_card_mutex);
         snd_cards[card->number] = NULL;
         clear_bit(card->number, snd_cards_lock);
-        }
+        mutex_unlock(&snd_card_mutex);
 
         snd_power_sync_ref(card);
@@ -578 +585 @@
         snd_card_disconnect(card);
 
-        guard(spinlock_irq)(&card->files_lock);
+        spin_lock_irq(&card->files_lock);
         wait_event_lock_irq(card->remove_sleep,
                             list_empty(&card->files_list),
                             card->files_lock);
+        spin_unlock_irq(&card->files_lock);
 }
 EXPORT_SYMBOL_GPL(snd_card_disconnect_sync);
@@ -777 +785 @@
         if (card->id[0] != '\0')
                 return;
-        guard(mutex)(&snd_card_mutex);
+        mutex_lock(&snd_card_mutex);
         snd_card_set_id_no_lock(card, nid, nid);
+        mutex_unlock(&snd_card_mutex);
 }
 EXPORT_SYMBOL(snd_card_set_id);
@@ -807 +816 @@
         memcpy(buf1, buf, copy);
         buf1[copy] = '\0';
-        guard(mutex)(&snd_card_mutex);
-        if (!card_id_ok(NULL, buf1))
+        mutex_lock(&snd_card_mutex);
+        if (!card_id_ok(NULL, buf1)) {
+                mutex_unlock(&snd_card_mutex);
                 return -EEXIST;
+        }
         strcpy(card->id, buf1);
         snd_info_card_id_change(card);
+        mutex_unlock(&snd_card_mutex);
 
         return count;
@@ -905 +917 @@
         if (err < 0)
                 return err;
-        scoped_guard(mutex, &snd_card_mutex) {
+        mutex_lock(&snd_card_mutex);
         if (snd_cards[card->number]) {
                 /* already registered */
+                mutex_unlock(&snd_card_mutex);
                 return snd_info_card_register(card); /* register pending info */
         }
@@ -913 +926 @@
                 /* make a unique id name from the given string */
                 char tmpid[sizeof(card->id)];
-
                 memcpy(tmpid, card->id, sizeof(card->id));
                 snd_card_set_id_no_lock(card, tmpid, tmpid);
@@ -919 +931 @@
                 /* create an id from either shortname or longname */
                 const char *src;
-
                 src = *card->shortname ? card->shortname : card->longname;
                 snd_card_set_id_no_lock(card, src,
@@ -925 +936 @@
         }
         snd_cards[card->number] = card;
-        }
+        mutex_unlock(&snd_card_mutex);
         err = snd_info_card_register(card);
         if (err < 0)
@@ -946 +957 @@
 
         for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
-                guard(mutex)(&snd_card_mutex);
+                mutex_lock(&snd_card_mutex);
                 card = snd_cards[idx];
                 if (card) {
@@ -958 +969 @@
                                         card->longname);
                 }
+                mutex_unlock(&snd_card_mutex);
         }
         if (!count)
@@ -970 +982 @@
 
         for (idx = count = 0; idx < SNDRV_CARDS; idx++) {
-                guard(mutex)(&snd_card_mutex);
+                mutex_lock(&snd_card_mutex);
                 card = snd_cards[idx];
                 if (card) {
@@ -976 +988 @@
                         snd_iprintf(buffer, "%s\n", card->longname);
                 }
+                mutex_unlock(&snd_card_mutex);
         }
         if (!count) {
@@ -992 +1005 @@
 
         for (idx = 0; idx < SNDRV_CARDS; idx++) {
-                guard(mutex)(&snd_card_mutex);
+                mutex_lock(&snd_card_mutex);
                 card = snd_cards[idx];
                 if (card)
                         snd_iprintf(buffer, "%2i %s\n",
                                     idx, card->module->name);
+                mutex_unlock(&snd_card_mutex);
         }
 }
@@ -1078 +1092 @@
         mfile->disconnected_f_op = NULL;
         INIT_LIST_HEAD(&mfile->shutdown_list);
-        guard(spinlock)(&card->files_lock);
+        spin_lock(&card->files_lock);
         if (card->shutdown) {
+        spin_unlock(&card->files_lock);
                 kfree(mfile);
                 return -ENODEV;
@@ -1106 +1121 @@
         struct snd_monitor_file *mfile, *found = NULL;
 
-        scoped_guard(spinlock, &card->files_lock) {
+        spin_lock(&card->files_lock);
         list_for_each_entry(mfile, &card->files_list, list, struct snd_monitor_file) {
                 if (mfile->file == file) {
                         list_del(&mfile->list);
-                                scoped_guard(spinlock, &shutdown_lock)
+                        spin_lock(&shutdown_lock);
                         list_del(&mfile->shutdown_list);
+                        spin_unlock(&shutdown_lock);
                         if (mfile->disconnected_f_op)
                                 fops_put(mfile->disconnected_f_op);
                         found = mfile;
                         break;
-                }
+                }
         }
         if (list_empty(&card->files_list))
                 wake_up_all(&card->remove_sleep);
-        }
+        spin_unlock(&card->files_lock);
         if (!found) {
                 dev_err(card->dev, "card file remove problem (%p)\n", file);

GPL/branches/uniaud32-exp/alsa-kernel/core/oss/pcm_oss.c ¶

@@ -1637 +1637 @@
                 result = 0;
                 set_current_state(TASK_INTERRUPTIBLE);
-                scoped_guard(pcm_stream_lock_irq, substream)
+                snd_pcm_stream_lock_irq(substream);
                 state = runtime->state;
+                snd_pcm_stream_unlock_irq(substream);
                 if (state != SNDRV_PCM_STATE_RUNNING) {
                         set_current_state(TASK_RUNNING);
@@ -2347 +2348 @@
         struct snd_pcm_oss_setup *setup;
 
-        guard(mutex)(&pcm->streams[stream].oss.setup_mutex);
+        mutex_lock(&pcm->streams[stream].oss.setup_mutex);
         do {
                 for (setup = pcm->streams[stream].oss.setup_list; setup;
@@ -2358 +2359 @@
         if (setup)
                 *rsetup = *setup;
+        mutex_unlock(&pcm->streams[stream].oss.setup_mutex);
 }
 
@@ -2852 +2854 @@
                 struct snd_pcm_runtime *runtime = psubstream->runtime;
                 poll_wait(file, &runtime->sleep, wait);
-                scoped_guard(pcm_stream_lock_irq, psubstream) {
+                snd_pcm_stream_lock_irq(psubstream);
                 if (runtime->state != SNDRV_PCM_STATE_DRAINING &&
                     (runtime->state != SNDRV_PCM_STATE_RUNNING ||
                      snd_pcm_oss_playback_ready(psubstream)))
                         mask |= EPOLLOUT | EPOLLWRNORM;
-                }
+                snd_pcm_stream_unlock_irq(psubstream);
         }
         if (csubstream != NULL) {
@@ -2863 +2865 @@
                 snd_pcm_state_t ostate;
                 poll_wait(file, &runtime->sleep, wait);
-                scoped_guard(pcm_stream_lock_irq, csubstream) {
+                snd_pcm_stream_lock_irq(csubstream);
                 ostate = runtime->state;
                 if (ostate != SNDRV_PCM_STATE_RUNNING ||
                     snd_pcm_oss_capture_ready(csubstream))
                         mask |= EPOLLIN | EPOLLRDNORM;
-                }
+                snd_pcm_stream_unlock_irq(csubstream);
                 if (ostate != SNDRV_PCM_STATE_RUNNING && runtime->oss.trigger) {
                         struct snd_pcm_oss_file ofile;
@@ -2965 +2967 @@
         struct snd_pcm_str *pstr = entry->private_data;
         struct snd_pcm_oss_setup *setup = pstr->oss.setup_list;
-        guard(mutex)(&pstr->oss.setup_mutex);
+        mutex_lock(&pstr->oss.setup_mutex);
         while (setup) {
                 snd_iprintf(buffer, "%s %u %u%s%s%s%s%s%s\n",
@@ -2979 +2981 @@
                 setup = setup->next;
         }
+        mutex_unlock(&pstr->oss.setup_mutex);
 }
 
@@ -3004 +3007 @@
 
         while (!snd_info_get_line(buffer, line, sizeof(line))) {
-                guard(mutex)(&pstr->oss.setup_mutex);
+                mutex_lock(&pstr->oss.setup_mutex);
                 memset(&template, 0, sizeof(template));
                 ptr = snd_info_get_str(task_name, line, sizeof(task_name));
                 if (!strcmp(task_name, "clear") || !strcmp(task_name, "erase")) {
                         snd_pcm_oss_proc_free_setup_list(pstr);
+                        mutex_unlock(&pstr->oss.setup_mutex);
                         continue;
                 }
@@ -3048 +3052 @@
                         if (! setup) {
                                 buffer->error = -ENOMEM;
+                                mutex_unlock(&pstr->oss.setup_mutex);
                                 return;
                         }
@@ -3065 +3070 @@
                 }
                 *setup = template;
+                mutex_unlock(&pstr->oss.setup_mutex);
         }
 }

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

@@ -95 +95 @@
                         if (get_user(device, (int __user *)arg))
                                 return -EFAULT;
-                        scoped_guard(mutex, &register_mutex)
+                        mutex_lock(&register_mutex);
                         device = snd_pcm_next(card, device);
+                        mutex_unlock(&register_mutex);
                         if (put_user(device, (int __user *)arg))
                                 return -EFAULT;
@@ -109 +110 @@
                         struct snd_pcm_str *pstr;
                         struct snd_pcm_substream *substream;
+                        int err;
 
                         info = (struct snd_pcm_info __user *)arg;
@@ -120 +122 @@
                         if (get_user(subdevice, &info->subdevice))
                                 return -EFAULT;
-                        guard(mutex)(&register_mutex);
+                        mutex_lock(&register_mutex);
                         pcm = snd_pcm_get(card, device);
-                        if (pcm == NULL)
-                                return -ENXIO;
-                        pstr = &pcm->streams[stream];
-                        if (pstr->substream_count == 0)
-                                return -ENOENT;
-                        if (subdevice >= pstr->substream_count)
-                                return -ENXIO;
+                        if (pcm == NULL) {
+                                err = -ENXIO;
+                                goto _error;
+                        }
+                        if (pstr->substream_count == 0) {
+                                err = -ENOENT;
+                                goto _error;
+                        }
+                        if (subdevice >= pstr->substream_count) {
+                                err = -ENXIO;
+                                goto _error;
+                        }
                         for (substream = pstr->substream; substream;
                              substream = substream->next)
                                 if (substream->number == (int)subdevice)
                                         break;
-                        if (substream == NULL)
-                                return -ENXIO;
-                        guard(mutex)(&pcm->open_mutex);
-                        return snd_pcm_info_user(substream, info);
+                        if (substream == NULL) {
+                                err = -ENXIO;
+                                goto _error;
+                        }
+                        mutex_lock(&pcm->open_mutex);
+                        err = snd_pcm_info_user(substream, info);
+                        mutex_unlock(&pcm->open_mutex);
+                _error:
+                        mutex_unlock(&register_mutex);
+                        return err;
                 }
         case SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE:
@@ -379 +392 @@
         struct snd_pcm_runtime *runtime;
 
-        guard(mutex)(&substream->pcm->open_mutex);
+        mutex_lock(&substream->pcm->open_mutex);
         runtime = substream->runtime;
         if (!runtime) {
                 snd_iprintf(buffer, "closed\n");
-                return;
+                goto unlock;
         }
         if (runtime->state == SNDRV_PCM_STATE_OPEN) {
                 snd_iprintf(buffer, "no setup\n");
-                return;
+                goto unlock;
         }
         snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access));
@@ -406 +419 @@
         }
 #endif
+ unlock:
+        mutex_unlock(&substream->pcm->open_mutex);
 }
 
@@ -414 +429 @@
         struct snd_pcm_runtime *runtime;
 
-        guard(mutex)(&substream->pcm->open_mutex);
+        mutex_lock(&substream->pcm->open_mutex);
         runtime = substream->runtime;
         if (!runtime) {
                 snd_iprintf(buffer, "closed\n");
-                return;
+                goto unlock;
         }
         if (runtime->state == SNDRV_PCM_STATE_OPEN) {
                 snd_iprintf(buffer, "no setup\n");
-                return;
+                goto unlock;
         }
         snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode));
@@ -432 +447 @@
         snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size);
         snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary);
+ unlock:
+        mutex_unlock(&substream->pcm->open_mutex);
 }
 
@@ -442 +459 @@
         int err;
 
-        guard(mutex)(&substream->pcm->open_mutex);
+        mutex_lock(&substream->pcm->open_mutex);
         runtime = substream->runtime;
         if (!runtime) {
                 snd_iprintf(buffer, "closed\n");
-                return;
+                goto unlock;
         }
         memset(&status, 0, sizeof(status));
@@ -452 +469 @@
         if (err < 0) {
                 snd_iprintf(buffer, "error %d\n", err);
-                return;
+                goto unlock;
         }
         snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state));
@@ -469 +486 @@
         snd_iprintf(buffer, "xrun_counter: %d\n", substream->xrun_counter);
 #endif
+ unlock:
+        mutex_unlock(&substream->pcm->open_mutex);
 }
 
@@ -1003 +1022 @@
         /* Avoid concurrent access to runtime via PCM timer interface */
         if (substream->timer) {
-                scoped_guard(spinlock_irq, &substream->timer->lock)
+                spin_lock_irq(&substream->timer->lock);
                 substream->runtime = NULL;
+                spin_unlock_irq(&substream->timer->lock);
         } else {
                 substream->runtime = NULL;
@@ -1063 +1083 @@
         pcm = device->device_data;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         err = snd_pcm_add(pcm);
         if (err)
-                return err;
+                goto unlock;
         for (cidx = 0; cidx < 2; cidx++) {
                 int devtype = -1;
@@ -1085 +1105 @@
                 if (err < 0) {
                         list_del_init(&pcm->list);
-                        return err;
+                        goto unlock;
                 }
 
@@ -1093 +1113 @@
 
         pcm_call_notify(pcm, n_register);
+
+ unlock:
+        mutex_unlock(&register_mutex);
         return err;
 }
@@ -1102 +1125 @@
         int cidx;
 
-        guard(mutex)(&register_mutex);
-        guard(mutex)(&pcm->open_mutex);
+        mutex_lock(&register_mutex);
+        mutex_lock(&pcm->open_mutex);
         wake_up(&pcm->open_wait);
         list_del_init(&pcm->list);
@@ -1130 +1153 @@
                 free_chmap(&pcm->streams[cidx]);
         }
+        mutex_unlock(&pcm->open_mutex);
+        mutex_unlock(&register_mutex);
         return 0;
 }
@@ -1154 +1179 @@
                        !notify->n_disconnect))
                 return -EINVAL;
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         if (nfree) {
                 list_del(&notify->list);
@@ -1164 +1189 @@
                         notify->n_register(pcm);
         }
+        mutex_unlock(&register_mutex);
         return 0;
 }
@@ -1179 +1205 @@
         struct snd_pcm *pcm;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         list_for_each_entry(pcm, &snd_pcm_devices, list, struct snd_pcm) {
                 snd_iprintf(buffer, "%02i-%02i: %s : %s",
@@ -1191 +1217 @@
                 snd_iprintf(buffer, "\n");
         }
+        mutex_unlock(&register_mutex);
 }
 

GPL/branches/uniaud32-exp/alsa-kernel/core/pcm_lib.c ¶

@@ -1801 +1801 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-
-        guard(pcm_stream_lock_irqsave)(substream);
+        unsigned long flags;
+        snd_pcm_stream_lock_irqsave(substream, flags);
         if (snd_pcm_running(substream) &&
             snd_pcm_update_hw_ptr(substream) >= 0)
@@ -1810 +1810 @@
                 runtime->hw_ptr_wrap = 0;
         }
+        snd_pcm_stream_unlock_irqrestore(substream, flags);
         return 0;
 }
@@ -1970 +1971 @@
 void snd_pcm_period_elapsed(struct snd_pcm_substream *substream)
 {
+        unsigned long flags;
+
         if (snd_BUG_ON(!substream))
                 return;
 
-        guard(pcm_stream_lock_irqsave)(substream);
+        snd_pcm_stream_lock_irqsave(substream, flags);
         snd_pcm_period_elapsed_under_stream_lock(substream);
+        snd_pcm_stream_unlock_irqrestore(substream, flags);
 }
 EXPORT_SYMBOL(snd_pcm_period_elapsed);

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

@@ -38 +38 @@
 static void update_allocated_size(struct snd_card *card, ssize_t bytes)
 {
-        guard(mutex)(&card->memory_mutex);
+        mutex_lock(&card->memory_mutex);
         __update_allocated_size(card, bytes);
+        mutex_unlock(&card->memory_mutex);
 }
 
 static void decrease_allocated_size(struct snd_card *card, size_t bytes)
 {
-        guard(mutex)(&card->memory_mutex);
+        mutex_lock(&card->memory_mutex);
         WARN_ON(card->total_pcm_alloc_bytes < bytes);
         __update_allocated_size(card, -(ssize_t)bytes);
+        mutex_unlock(&card->memory_mutex);
 }
 
@@ -56 +58 @@
 
         /* check and reserve the requested size */
-        scoped_guard(mutex, &card->memory_mutex) {
+        mutex_lock(&card->memory_mutex);
         if (max_alloc_per_card &&
-                    card->total_pcm_alloc_bytes + size > max_alloc_per_card)
+            card->total_pcm_alloc_bytes + size > max_alloc_per_card) {
+                mutex_unlock(&card->memory_mutex);
                 return -ENOMEM;
+        }
         __update_allocated_size(card, size);
-        }
+        mutex_unlock(&card->memory_mutex);
 
         if (str == SNDRV_PCM_STREAM_PLAYBACK)
@@ -188 +192 @@
         struct snd_card *card = substream->pcm->card;
         char line[64], str[64];
-        unsigned long size;
+        size_t size;
         struct snd_dma_buffer new_dmab;
 
-        guard(mutex)(&substream->pcm->open_mutex);
+        mutex_lock(&substream->pcm->open_mutex);
         if (substream->runtime) {
                 buffer->error = -EBUSY;
@@ -198 +202 @@
         if (!snd_info_get_line(buffer, line, sizeof(line))) {
                 snd_info_get_str(str, line, sizeof(str));
-                buffer->error = kstrtoul(str, 10, &size);
-                if (buffer->error != 0)
-                        return;
-                size *= 1024;
+                size = simple_strtoul(str, NULL, 10) * 1024;
                 if ((size != 0 && size < 8192) || size > substream->dma_max) {
                         buffer->error = -EINVAL;
-                        return;
+                        goto unlock;
                 }
                 if (substream->dma_buffer.bytes == size)
-                        return;
+                        goto unlock;
                 memset(&new_dmab, 0, sizeof(new_dmab));
                 new_dmab.dev = substream->dma_buffer.dev;
@@ -221 +222 @@
                                          substream->stream ? 'c' : 'p', substream->number,
                                          substream->pcm->name, size);
-                                return;
+                                goto unlock;
                         }
                         substream->buffer_bytes_max = size;

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

@@ -620 +620 @@
                               snd_pcm_state_t state)
 {
-        guard(pcm_stream_lock_irq)(substream);
+        snd_pcm_stream_lock_irq(substream);
         if (substream->runtime->state != SNDRV_PCM_STATE_DISCONNECTED)
                 __snd_pcm_set_state(substream->runtime, state);
+        snd_pcm_stream_unlock_irq(substream);
 }
 
@@ -750 +751 @@
         if (err < 0)
                 return err;
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         switch (runtime->state) {
         case SNDRV_PCM_STATE_OPEN:
@@ -757 +758 @@
                 if (!is_oss_stream(substream) &&
                     atomic_read(&substream->mmap_count))
-                        err = -EBADFD;
+                err = -EBADFD;
                 break;
         default:
@@ -763 +764 @@
                 break;
         }
-        }
+        snd_pcm_stream_unlock_irq(substream);
         if (err)
                 goto unlock;
@@ -913 +914 @@
         if (result < 0)
                 return result;
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         switch (runtime->state) {
         case SNDRV_PCM_STATE_SETUP:
         case SNDRV_PCM_STATE_PREPARED:
                 if (atomic_read(&substream->mmap_count))
-                        result = -EBADFD;
+                result = -EBADFD;
                 break;
         default:
@@ -924 +925 @@
                 break;
         }
-        }
+        snd_pcm_stream_unlock_irq(substream);
         if (result)
                 goto unlock;
@@ -944 +945 @@
                 return -ENXIO;
         runtime = substream->runtime;
-        scoped_guard(pcm_stream_lock_irq, substream) {
-                if (runtime->state == SNDRV_PCM_STATE_OPEN)
+        snd_pcm_stream_lock_irq(substream);
+        if (runtime->state == SNDRV_PCM_STATE_OPEN) {
+                snd_pcm_stream_unlock_irq(substream);
                 return -EBADFD;
         }
+        snd_pcm_stream_unlock_irq(substream);
 
         if (params->tstamp_mode < 0 ||
@@ -967 +970 @@
         }
         err = 0;
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         runtime->tstamp_mode = params->tstamp_mode;
         if (params->proto >= SNDRV_PROTOCOL_VERSION(2, 0, 12))
@@ -984 +987 @@
                 err = snd_pcm_update_state(substream, runtime);
         }
-        }
+        snd_pcm_stream_unlock_irq(substream);
         return err;
 }
@@ -1018 +1021 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
 
-        guard(pcm_stream_lock_irq)(substream);
+        snd_pcm_stream_lock_irq(substream);
 
         snd_pcm_unpack_audio_tstamp_config(status->audio_tstamp_data,
@@ -1039 +1042 @@
         status->suspended_state = runtime->suspended_state;
         if (status->state == SNDRV_PCM_STATE_OPEN)
-                return 0;
+                goto _end;
         status->trigger_tstamp_sec = runtime->trigger_tstamp.tv_sec;
         status->trigger_tstamp_nsec = runtime->trigger_tstamp.tv_nsec;
@@ -1084 +1087 @@
         runtime->avail_max = 0;
         runtime->overrange = 0;
+ _end:
+        snd_pcm_stream_unlock_irq(substream);
         return 0;
 }
@@ -1189 +1194 @@
         channel = info->channel;
         runtime = substream->runtime;
-        scoped_guard(pcm_stream_lock_irq, substream) {
-                if (runtime->state == SNDRV_PCM_STATE_OPEN)
+        snd_pcm_stream_lock_irq(substream);
+        if (runtime->state == SNDRV_PCM_STATE_OPEN) {
+                snd_pcm_stream_unlock_irq(substream);
                 return -EBADFD;
         }
+        snd_pcm_stream_unlock_irq(substream);
         if (channel >= runtime->channels)
                 return -EINVAL;
@@ -1413 +1420 @@
                                    snd_pcm_state_t state)
 {
-        guard(pcm_stream_lock_irq)(substream);
-        return snd_pcm_action(ops, substream, state);
+        int res;
+
+        snd_pcm_stream_lock_irq(substream);
+        res = snd_pcm_action(ops, substream, state);
+        snd_pcm_stream_unlock_irq(substream);
+        return res;
 }
 
@@ -1426 +1437 @@
 
         /* Guarantee the group members won't change during non-atomic action */
-        guard(rwsem_read)(&snd_pcm_link_rwsem);
+        down_read(&snd_pcm_link_rwsem);
         res = snd_pcm_buffer_access_lock(substream->runtime);
         if (res < 0)
-                return res;
+                goto unlock;
         if (snd_pcm_stream_linked(substream))
                 res = snd_pcm_action_group(ops, substream, state, false);
@@ -1435 +1446 @@
                 res = snd_pcm_action_single(ops, substream, state);
         snd_pcm_buffer_access_unlock(substream->runtime);
+ unlock:
+        up_read(&snd_pcm_link_rwsem);
         return res;
 }
@@ -1604 +1617 @@
 int snd_pcm_stop_xrun(struct snd_pcm_substream *substream)
 {
-        guard(pcm_stream_lock_irqsave)(substream);
+        unsigned long flags;
+
+        snd_pcm_stream_lock_irqsave(substream, flags);
         if (substream->runtime && snd_pcm_running(substream))
                 __snd_pcm_xrun(substream);
+        snd_pcm_stream_unlock_irqrestore(substream, flags);
         return 0;
 }
@@ -1758 +1774 @@
 static int snd_pcm_suspend(struct snd_pcm_substream *substream)
 {
-        guard(pcm_stream_lock_irqsave)(substream);
-        return snd_pcm_action(&snd_pcm_action_suspend, substream,
+        int err;
+        unsigned long flags;
+
+        snd_pcm_stream_lock_irqsave(substream, flags);
+        err = snd_pcm_action(&snd_pcm_action_suspend, substream,
                              ACTION_ARG_IGNORE);
+        snd_pcm_stream_unlock_irqrestore(substream, flags);
+        return err;
 }
 
@@ -1878 +1899 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-
-        guard(pcm_stream_lock_irq)(substream);
+        int result;
+
+        snd_pcm_stream_lock_irq(substream);
         switch (runtime->state) {
         case SNDRV_PCM_STATE_XRUN:
-                return 0;       /* already there */
+                result = 0;     /* already there */
+                break;
         case SNDRV_PCM_STATE_RUNNING:
                 __snd_pcm_xrun(substream);
-                return 0;
+                result = 0;     /* already there */
+                break;
         default:
-                return -EBADFD;
-        }
+                result -EBADFD;
+        }
+        snd_pcm_stream_unlock_irq(substream);
+        return result;
 }
 
@@ -1917 +1943 @@
         if (err < 0)
                 return err;
-        guard(pcm_stream_lock_irq)(substream);
+        snd_pcm_stream_lock_irq(substream);
         runtime->hw_ptr_base = 0;
         runtime->hw_ptr_interrupt = runtime->status->hw_ptr -
@@ -1923 +1949 @@
         runtime->silence_start = runtime->status->hw_ptr;
         runtime->silence_filled = 0;
+        snd_pcm_stream_unlock_irq(substream);
         return 0;
 }
@@ -1930 +1957 @@
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
-        guard(pcm_stream_lock_irq)(substream);
+        snd_pcm_stream_lock_irq(substream);
         runtime->control->appl_ptr = runtime->status->hw_ptr;
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
             runtime->silence_size > 0)
                 snd_pcm_playback_silence(substream, ULONG_MAX);
+        snd_pcm_stream_unlock_irq(substream);
 }
 
@@ -2010 +2038 @@
                 f_flags = substream->f_flags;
 
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         switch (substream->runtime->state) {
         case SNDRV_PCM_STATE_PAUSED:
@@ -2019 +2047 @@
                 break;
         }
-        }
+        snd_pcm_stream_unlock_irq(substream);
 
         return snd_pcm_action_nonatomic(&snd_pcm_action_prepare,
@@ -2236 +2264 @@
                 return -EBADFD;
 
-        guard(pcm_stream_lock_irq)(substream);
+        snd_pcm_stream_lock_irq(substream);
         /* resume pause */
         if (runtime->state == SNDRV_PCM_STATE_PAUSED)
@@ -2243 +2271 @@
         snd_pcm_stop(substream, SNDRV_PCM_STATE_SETUP);
         /* runtime->control->appl_ptr = runtime->status->hw_ptr; */
+        snd_pcm_stream_unlock_irq(substream);
 
         return result;
@@ -2271 +2300 @@
 static int snd_pcm_link(struct snd_pcm_substream *substream, int fd)
 {
+        int res = 0;
         struct snd_pcm_file *pcm_file;
         struct snd_pcm_substream *substream1;
@@ -2283 +2313 @@
 #endif
 
-        if (!fd_file(f))
+        if (!f.file)
                 return -EBADFD;
-        if (!is_pcm_file(fd_file(f)))
-                return -EBADFD;
-
-        pcm_file = fd_file(f)->private_data;
+        if (!is_pcm_file(f.file)) {
+                res = -EBADFD;
+                goto _badf;
+        }
+        pcm_file = f.file->private_data;
         substream1 = pcm_file->substream;
 
@@ -2295 +2326 @@
 
         group = kzalloc(sizeof(*group), GFP_KERNEL);
-        if (!group)
-                return -ENOMEM;
+        if (!group) {
+                res = -ENOMEM;
+                goto _nolock;
+        }
         snd_pcm_group_init(group);
 
-        guard(rwsem_write)(&snd_pcm_link_rwsem);
+        down_write(&snd_pcm_link_rwsem);
         if (substream->runtime->state == SNDRV_PCM_STATE_OPEN ||
             substream->runtime->state != substream1->runtime->state ||
-            substream->pcm->nonatomic != substream1->pcm->nonatomic)
-                return -EBADFD;
-        if (snd_pcm_stream_linked(substream1))
-                return -EALREADY;
-
-        scoped_guard(pcm_stream_lock_irq, substream) {
+            substream->pcm->nonatomic != substream1->pcm->nonatomic) {
+                res = -EBADFD;
+                goto _end;
+        }
+        if (snd_pcm_stream_linked(substream1)) {
+                res = -EALREADY;
+                goto _end;
+        }
+
+        snd_pcm_stream_lock_irq(substream);
         if (!snd_pcm_stream_linked(substream)) {
                 snd_pcm_group_assign(substream, group);
@@ -2313 +2350 @@
         }
         target_group = substream->group;
-        }
+        snd_pcm_stream_unlock_irq(substream);
 
         snd_pcm_group_lock_irq(target_group, nonatomic);
@@ -2321 +2358 @@
         snd_pcm_stream_unlock(substream1);
         snd_pcm_group_unlock_irq(target_group, nonatomic);
-        return 0;
+ _end:
+        up_write(&snd_pcm_link_rwsem);
+ _nolock:
+        kfree(group);
+ _badf:
+#ifndef TARGET_OS2
+        fdput(f);
+#endif
+        return res;
 }
 
@@ -2336 +2381 @@
         bool nonatomic = substream->pcm->nonatomic;
         bool do_free = false;
-
-        guard(rwsem_write)(&snd_pcm_link_rwsem);
-
-        if (!snd_pcm_stream_linked(substream))
-                return -EALREADY;
+        int res = 0;
+
+        down_write(&snd_pcm_link_rwsem);
+
+        if (!snd_pcm_stream_linked(substream)) {
+                res = -EALREADY;
+                goto _end;
+        }
 
         group = substream->group;
@@ -2359 +2407 @@
         if (do_free)
                 kfree(group);
-        return 0;
+
+       _end:
+        up_write(&snd_pcm_link_rwsem);
+        return res;
 }
 
@@ -2939 +2990 @@
         snd_power_wait(pcm->card);
 
-        scoped_guard(mutex, &pcm->open_mutex) {
+        mutex_lock(&pcm->open_mutex);
         snd_pcm_release_substream(substream);
         kfree(pcm_file);
-        }
+        mutex_unlock(&pcm->open_mutex);
         wake_up(&pcm->open_wait);
         module_put(pcm->card->module);
@@ -3026 +3077 @@
                 return 0;
 
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         ret = do_pcm_hwsync(substream);
         if (!ret)
                 ret = rewind_appl_ptr(substream, frames,
                                       snd_pcm_hw_avail(substream));
-        }
+        snd_pcm_stream_unlock_irq(substream);
 #ifndef TARGET_OS2
         if (ret >= 0)
@@ -3047 +3098 @@
                 return 0;
 
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         ret = do_pcm_hwsync(substream);
         if (!ret)
                 ret = forward_appl_ptr(substream, frames,
                                        snd_pcm_avail(substream));
-        }
+        snd_pcm_stream_unlock_irq(substream);
 #ifndef TARGET_OS2
         if (ret >= 0)
@@ -3065 +3116 @@
         int err;
 
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         err = do_pcm_hwsync(substream);
         if (delay && !err)
                 *delay = snd_pcm_calc_delay(substream);
-        }
+        snd_pcm_stream_unlock_irq(substream);
 #ifndef TARGET_OS2
         snd_pcm_dma_buffer_sync(substream, SNDRV_DMA_SYNC_CPU);
@@ -3102 +3153 @@
                         return err;
         }
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) {
                 err = pcm_lib_apply_appl_ptr(substream,
                                              sync_ptr.c.control.appl_ptr);
-                        if (err < 0)
+                if (err < 0) {
+                        snd_pcm_stream_unlock_irq(substream);
                         return err;
+        }
         } else {
                 sync_ptr.c.control.appl_ptr = control->appl_ptr;
@@ -3120 +3173 @@
         sync_ptr.s.status.suspended_state = status->suspended_state;
         sync_ptr.s.status.audio_tstamp = status->audio_tstamp;
-        }
+        snd_pcm_stream_unlock_irq(substream);
 #ifndef TARGET_OS2
         if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL))
@@ -3208 +3261 @@
         if (! boundary)
                 boundary = 0x7fffffff;
-        scoped_guard(pcm_stream_lock_irq, substream) {
+        snd_pcm_stream_lock_irq(substream);
         /* FIXME: we should consider the boundary for the sync from app */
         if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL)) {
                 err = pcm_lib_apply_appl_ptr(substream,
                                 scontrol.appl_ptr);
-                        if (err < 0)
+                if (err < 0) {
+                        snd_pcm_stream_unlock_irq(substream);
                         return err;
+                }
         } else
                 scontrol.appl_ptr = control->appl_ptr % boundary;
@@ -3226 +3281 @@
         sstatus.suspended_state = status->suspended_state;
         sstatus.audio_tstamp = status->audio_tstamp;
-        }
+        snd_pcm_stream_unlock_irq(substream);
 #ifndef TARGET_OS2
         if (!(sflags & SNDRV_PCM_SYNC_PTR_APPL))
@@ -3584 +3639 @@
             runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
-        if (!user_backed_iter(to))
+        if (!to->user_backed)
                 return -EINVAL;
         if (to->nr_segs > 1024 || to->nr_segs != runtime->channels)
@@ -3623 +3678 @@
             runtime->state == SNDRV_PCM_STATE_DISCONNECTED)
                 return -EBADFD;
-        if (!user_backed_iter(from))
+        if (!from->user_backed)
                 return -EINVAL;
         if (from->nr_segs > 128 || from->nr_segs != runtime->channels ||
@@ -3667 +3722 @@
 
         mask = 0;
-        guard(pcm_stream_lock_irq)(substream);
+        snd_pcm_stream_lock_irq(substream);
         avail = snd_pcm_avail(substream);
         switch (runtime->state) {
@@ -3687 +3742 @@
                 break;
         }
+        snd_pcm_stream_unlock_irq(substream);
         return mask;
 }

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

@@ -124 +124 @@
 static bool snd_rawmidi_ready(struct snd_rawmidi_substream *substream)
 {
-        guard(spinlock_irqsave)(&substream->lock);
-        return __snd_rawmidi_ready(substream->runtime);
+        unsigned long flags;
+        bool ready;
+
+        spin_lock_irqsave(&substream->lock, flags);
+        ready = __snd_rawmidi_ready(substream->runtime);
+        spin_unlock_irqrestore(&substream->lock, flags);
+        return ready;
 }
 
@@ -254 +259 @@
                                bool is_input)
 {
-        guard(spinlock_irqsave)(&substream->lock);
+        unsigned long 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);
 }
 
@@ -273 +281 @@
         struct snd_rawmidi_runtime *runtime;
 
-        scoped_guard(spinlock_irq, &substream->lock) {
+        spin_lock_irq(&substream->lock);
         runtime = substream->runtime;
-                if (!substream->opened || !runtime || !runtime->buffer)
-                        return -EINVAL;
+        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
@@ -289 +301 @@
 #endif
 
-        scoped_guard(spinlock_irq, &substream->lock) {
+        spin_lock_irq(&substream->lock);
         if (signal_pending(current))
                 err = -ERESTARTSYS;
@@ -299 +311 @@
         }
         runtime->drain = 0;
-        }
+        spin_unlock_irq(&substream->lock);
 
         if (err != -ERESTARTSYS) {
@@ -310 +322 @@
         }
 
-        scoped_guard(spinlock_irq, &substream->lock)
+        spin_lock_irq(&substream->lock);
         snd_rawmidi_buffer_unref(runtime);
+        spin_unlock_irq(&substream->lock);
 
         return err;
@@ -375 +388 @@
                         return err;
                 }
-                guard(spinlock_irq)(&substream->lock);
+                spin_lock_irq(&substream->lock);
                 substream->opened = 1;
                 substream->active_sensing = 0;
@@ -382 +395 @@
                 substream->pid = get_pid(task_pid(current));
                 rmidi->streams[substream->stream].substream_opened++;
+                spin_unlock_irq(&substream->lock);
         }
         substream->use_count++;
@@ -444 +458 @@
                 return -ENXIO;
 
-        guard(mutex)(&rmidi->open_mutex);
+        mutex_lock(&rmidi->open_mutex);
         err = rawmidi_open_priv(rmidi, subdevice, mode, rfile);
+        mutex_unlock(&rmidi->open_mutex);
         if (err < 0)
                 module_put(rmidi->card->module);
@@ -578 +593 @@
                 snd_rawmidi_buffer_ref_sync(substream);
         }
-        scoped_guard(spinlock_irq, &substream->lock) {
+        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)
@@ -596 +611 @@
 
         rmidi = rfile->rmidi;
-        guard(mutex)(&rmidi->open_mutex);
+        mutex_lock(&rmidi->open_mutex);
         if (rfile->input) {
                 close_substream(rmidi, rfile->input, 1);
@@ -606 +621 @@
         }
         rfile->rmidi = NULL;
+        mutex_unlock(&rmidi->open_mutex);
         wake_up(&rmidi->open_wait);
 }
@@ -706 +722 @@
 int snd_rawmidi_info_select(struct snd_card *card, struct snd_rawmidi_info *info)
 {
-        guard(mutex)(&register_mutex);
-        return __snd_rawmidi_info_select(card, info);
+        int ret;
+
+        mutex_lock(&register_mutex);
+        ret = __snd_rawmidi_info_select(card, info);
+        mutex_unlock(&register_mutex);
+        return ret;
 }
 EXPORT_SYMBOL(snd_rawmidi_info_select);
@@ -774 +794 @@
 
         snd_rawmidi_drain_output(substream);
-        guard(mutex)(&substream->rmidi->open_mutex);
+        mutex_lock(&substream->rmidi->open_mutex);
         if (substream->append && substream->use_count > 1)
-                return -EBUSY;
+                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;
 }
@@ -792 +815 @@
 
         snd_rawmidi_drain_input(substream);
-        guard(mutex)(&substream->rmidi->open_mutex);
+        mutex_lock(&substream->rmidi->open_mutex);
         if (framing == SNDRV_RAWMIDI_MODE_FRAMING_NONE && clock_type != SNDRV_RAWMIDI_MODE_CLOCK_NONE)
                 err = -EINVAL;
@@ -806 +829 @@
                 substream->clock_type = clock_type;
         }
+        mutex_unlock(&substream->rmidi->open_mutex);
         return 0;
 }
@@ -818 +842 @@
         memset(status, 0, sizeof(*status));
         status->stream = SNDRV_RAWMIDI_STREAM_OUTPUT;
-        guard(spinlock_irq)(&substream->lock);
+        spin_lock_irq(&substream->lock);
         status->avail = runtime->avail;
+        spin_unlock_irq(&substream->lock);
         return 0;
 }
@@ -830 +855 @@
         memset(status, 0, sizeof(*status));
         status->stream = SNDRV_RAWMIDI_STREAM_INPUT;
-        guard(spinlock_irq)(&substream->lock);
+        spin_lock_irq(&substream->lock);
         status->avail = runtime->avail;
         status->xruns = runtime->xruns;
         runtime->xruns = 0;
+        spin_unlock_irq(&substream->lock);
         return 0;
 }
@@ -1028 +1054 @@
         if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */
                 device = SNDRV_RAWMIDI_DEVICES - 1;
-        scoped_guard(mutex, &register_mutex) {
+        mutex_lock(&register_mutex);
         device = device < 0 ? 0 : device + 1;
         for (; device < SNDRV_RAWMIDI_DEVICES; device++) {
@@ -1040 +1066 @@
         if (device == SNDRV_RAWMIDI_DEVICES)
                 device = -1;
-        }
+        mutex_unlock(&register_mutex);
         if (put_user(device, argp))
                 return -EFAULT;
@@ -1053 +1079 @@
         struct snd_ump_endpoint_info __user *info = argp;
         struct snd_rawmidi *rmidi;
-        int device;
+        int device, ret;
 
         if (get_user(device, &info->device))
                 return -EFAULT;
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         rmidi = snd_rawmidi_search(card, device);
         if (rmidi && rmidi->ops && rmidi->ops->ioctl)
-                return rmidi->ops->ioctl(rmidi, cmd, argp);
+                ret = rmidi->ops->ioctl(rmidi, cmd, argp);
         else
-                return -ENXIO;
+                ret = -ENXIO;
+        mutex_unlock(&register_mutex);
+        return ret;
 }
 #endif
@@ -1176 +1204 @@
                         const unsigned char *buffer, int count)
 {
+        unsigned long flags;
         struct timespec64 ts64 = get_framing_tstamp(substream);
         int result = 0, count1;
         struct snd_rawmidi_runtime *runtime;
 
-        guard(spinlock_irqsave)(&substream->lock);
-        if (!substream->opened)
-                return -EBADFD;
+        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;
+                result = -EINVAL;
+                goto unlock;
         }
 
         count = get_aligned_size(runtime, count);
         if (!count)
-                return result;
+                goto unlock;
 
         if (substream->framing == SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP) {
@@ -1215 +1247 @@
                 count1 = get_aligned_size(runtime, count1);
                 if (!count1)
-                        return result;
+                        goto unlock;
                 memcpy(runtime->buffer + runtime->hw_ptr, buffer, count1);
                 runtime->hw_ptr += count1;
@@ -1243 +1275 @@
                         wake_up(&runtime->sleep);
         }
+ unlock:
+        spin_unlock_irqrestore(&substream->lock, flags);
         return result;
 }
@@ -1365 +1399 @@
         struct snd_rawmidi_runtime *runtime;
 
-        guard(spinlock_irqsave)(&substream->lock);
+        int result;
+        unsigned long flags;
+ 
+        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;
-        }
-        return (runtime->avail >= runtime->buffer_size);
+                result = 1;
+        } else {
+                result = runtime->avail >= runtime->buffer_size;
+        }
+        spin_unlock_irqrestore(&substream->lock, flags);
+        return result;
 }
 EXPORT_SYMBOL(snd_rawmidi_transmit_empty);
@@ -1446 +1486 @@
                               unsigned char *buffer, int count)
 {
-        guard(spinlock_irqsave)(&substream->lock);
+        int result;
+        unsigned long flags;
+
+        spin_lock_irqsave(&substream->lock, flags);
         if (!substream->opened || !substream->runtime)
-                return -EBADFD;
-        return __snd_rawmidi_transmit_peek(substream, buffer, count);
+                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);
@@ -1496 +1542 @@
 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream *substream, int count)
 {
-        guard(spinlock_irqsave)(&substream->lock);
+        int result;
+        unsigned long flags;
+
+        spin_lock_irqsave(&substream->lock, flags);
         if (!substream->opened || !substream->runtime)
-                return -EBADFD;
-        return __snd_rawmidi_transmit_ack(substream, count);
+                result = -EBADFD;
+        else
+                result = __snd_rawmidi_transmit_ack(substream, count);
+        spin_unlock_irqrestore(&substream->lock, flags);
+        return result;
 }
 EXPORT_SYMBOL(snd_rawmidi_transmit_ack);
@@ -1516 +1568 @@
                          unsigned char *buffer, int count)
 {
-        guard(spinlock_irqsave)(&substream->lock);
+        int result;
+        unsigned long flags;
+
+        spin_lock_irqsave(&substream->lock, flags);
         if (!substream->opened)
-                return -EBADFD;
+                result = -EBADFD;
+        else {
                 count = __snd_rawmidi_transmit_peek(substream, buffer, count);
                 if (count <= 0)
-                return count;
-        return __snd_rawmidi_transmit_ack(substream, count);
+                        result = count;
+                else
+                        result = __snd_rawmidi_transmit_ack(substream, count);
+        }
+        spin_unlock_irqrestore(&substream->lock, flags);
+        return result;
 }
 EXPORT_SYMBOL(snd_rawmidi_transmit);
@@ -1535 +1595 @@
 {
         struct snd_rawmidi_runtime *runtime;
+        unsigned long flags;
         int count = 0;
 
-        guard(spinlock_irqsave)(&substream->lock);
+        spin_lock_irqsave(&substream->lock, flags);
         runtime = substream->runtime;
         if (substream->opened && runtime &&
@@ -1544 +1605 @@
                 __snd_rawmidi_transmit_ack(substream, count);
         }
+        spin_unlock_irqrestore(&substream->lock, flags);
         return count;
 }
@@ -1749 +1811 @@
         if (rmidi->ops && rmidi->ops->proc_read)
                 rmidi->ops->proc_read(entry, buffer);
-        guard(mutex)(&rmidi->open_mutex);
+        mutex_lock(&rmidi->open_mutex);
         if (rmidi->info_flags & SNDRV_RAWMIDI_INFO_OUTPUT) {
                 list_for_each_entry(substream,
@@ -1764 +1826 @@
                                     pid_vnr(substream->pid));
                                 runtime = substream->runtime;
-                                scoped_guard(spinlock_irq, &substream->lock) {
+                                spin_lock_irq(&substream->lock);
                                 buffer_size = runtime->buffer_size;
                                 avail = runtime->avail;
-                                }
+                                spin_unlock_irq(&substream->lock);
                                 snd_iprintf(buffer,
                                     "  Mode         : %s\n"
@@ -1791 +1853 @@
                                             pid_vnr(substream->pid));
                                 runtime = substream->runtime;
-                                scoped_guard(spinlock_irq, &substream->lock) {
+                                spin_lock_irq(&substream->lock);
                                 buffer_size = runtime->buffer_size;
                                 avail = runtime->avail;
                                 xruns = runtime->xruns;
-                                }
+                                spin_unlock_irq(&substream->lock);
                                 snd_iprintf(buffer,
                                             "  Buffer size  : %lu\n"
@@ -1812 +1874 @@
                 }
         }
+        mutex_unlock(&rmidi->open_mutex);
 }
 
@@ -2001 +2064 @@
                 return -ENOMEM;
         err = 0;
-        scoped_guard(mutex, &register_mutex) {
+        mutex_lock(&register_mutex);
         if (snd_rawmidi_search(rmidi->card, rmidi->device))
                 err = -EBUSY;
         else
                 list_add_tail(&rmidi->list, &snd_rawmidi_devices);
-        }
+        mutex_unlock(&register_mutex);
         if (err < 0)
                 return err;
@@ -2079 +2142 @@
         snd_unregister_device(rmidi->dev);
  error:
-        scoped_guard(mutex, &register_mutex)
+        mutex_lock(&register_mutex);
         list_del(&rmidi->list);
+        mutex_unlock(&register_mutex);
         return err;
 }
@@ -2089 +2153 @@
         int dir;
 
-        guard(mutex)(&register_mutex);
-        guard(mutex)(&rmidi->open_mutex);
+        mutex_lock(&register_mutex);
+        mutex_lock(&rmidi->open_mutex);
         wake_up(&rmidi->open_wait);
         list_del_init(&rmidi->list);
@@ -2116 +2180 @@
 #endif /* CONFIG_SND_OSSEMUL */
         snd_unregister_device(rmidi->dev);
+        mutex_unlock(&rmidi->open_mutex);
+        mutex_unlock(&register_mutex);
         return 0;
 }

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_fifo.c ¶

@@ -89 +89 @@
 
         snd_use_lock_sync(&f->use_lock);
-        guard(spinlock_irq)(&f->lock);
+        spin_lock_irq(&f->lock);
         /* drain the fifo */
         while ((cell = fifo_cell_out(f)) != NULL) {
                 snd_seq_cell_free(cell);
         }
+        spin_unlock_irq(&f->lock);
 }
 
@@ -102 +103 @@
 {
         struct snd_seq_event_cell *cell;
+        unsigned long flags;
         int err;
 
@@ -117 +119 @@
                 
         /* append new cells to fifo */
-        scoped_guard(spinlock_irqsave, &f->lock) {
+        spin_lock_irqsave(&f->lock, flags);
         if (f->tail != NULL)
                 f->tail->next = cell;
@@ -125 +127 @@
         cell->next = NULL;
         f->cells++;
-        }
+        spin_unlock_irqrestore(&f->lock, flags);
 
         /* wakeup client */
@@ -198 +200 @@
                                struct snd_seq_event_cell *cell)
 {
+        unsigned long flags;
+
         if (cell) {
-                guard(spinlock_irqsave)(&f->lock);
+                spin_lock_irqsave(&f->lock, flags);
                 cell->next = f->head;
                 f->head = cell;
@@ -205 +209 @@
                         f->tail = cell;
                 f->cells++;
+                spin_unlock_irqrestore(&f->lock, flags);
         }
 }
@@ -235 +240 @@
         }
 
-        scoped_guard(spinlock_irq, &f->lock) {
+        spin_lock_irq(&f->lock);
         /* remember old pool */
         oldpool = f->pool;
@@ -245 +250 @@
         f->cells = 0;
         /* NOTE: overflow flag is not cleared */
-        }
+        spin_unlock_irq(&f->lock);
 
         /* close the old pool and wait until all users are gone */
@@ -264 +269 @@
 int snd_seq_fifo_unused_cells(struct snd_seq_fifo *f)
 {
+        unsigned long flags;
         int cells;
 
@@ -270 +276 @@
 
         snd_use_lock_use(&f->use_lock);
-        scoped_guard(spinlock_irqsave, &f->lock)
+        spin_lock_irqsave(&f->lock, flags);
         cells = snd_seq_unused_cells(f->pool);
+        spin_unlock_irqrestore(&f->lock, flags);
         snd_use_lock_free(&f->use_lock);
         return cells;

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_memory.c ¶

@@ -233 +233 @@
 void snd_seq_cell_free(struct snd_seq_event_cell * cell)
 {
+        unsigned long flags;
         struct snd_seq_pool *pool;
 
@@ -241 +242 @@
                 return;
 
-        guard(spinlock_irqsave)(&pool->lock);
+        spin_lock_irqsave(&pool->lock, flags);
         free_cell(pool, cell);
         if (snd_seq_ev_is_variable(&cell->event)) {
@@ -259 +260 @@
                         wake_up(&pool->output_sleep);
         }
+        spin_unlock_irqrestore(&pool->lock, flags);
 }
 
@@ -448 +450 @@
 
         /* add new cells to the free cell list */
-        guard(spinlock_irq)(&pool->lock);
+        spin_lock_irq(&pool->lock);
         if (pool->ptr) {
+                spin_unlock_irq(&pool->lock);
                 kvfree(cellptr);
                 return 0;
@@ -468 +471 @@
         pool->max_used = 0;
         pool->total_elements = pool->size;
+        spin_unlock_irq(&pool->lock);
         return 0;
 }
@@ -474 +478 @@
 void snd_seq_pool_mark_closing(struct snd_seq_pool *pool)
 {
+        unsigned long flags;
+
         if (snd_BUG_ON(!pool))
                 return;
-        guard(spinlock_irqsave)(&pool->lock);
+        spin_lock_irqsave(&pool->lock, flags);
         pool->closing = 1;
+        spin_unlock_irqrestore(&pool->lock, flags);
 }
 
@@ -498 +505 @@
         
         /* release all resources */
-        scoped_guard(spinlock_irq, &pool->lock) {
+        spin_lock_irq(&pool->lock);
         ptr = pool->ptr;
         pool->ptr = NULL;
         pool->free = NULL;
         pool->total_elements = 0;
-        }
+        spin_unlock_irq(&pool->lock);
 
         kvfree(ptr);
 
-        guard(spinlock_irq)(&pool->lock);
+        spin_lock_irq(&pool->lock);
         pool->closing = 0;
+        spin_unlock_irq(&pool->lock);
 
         return 0;

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_midi.c ¶

@@ -307 +307 @@
                 ports = 256 / SNDRV_RAWMIDI_DEVICES;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         client = synths[card->number];
         if (client == NULL) {
                 newclient = 1;
                 client = kzalloc(sizeof(*client), GFP_KERNEL);
-                if (client == NULL)
+                if (client == NULL) {
+                        mutex_unlock(&register_mutex);
+                        kfree(info);
                         return -ENOMEM;
+                }
                 client->seq_client =
                         snd_seq_create_kernel_client(
@@ -320 +323 @@
                 if (client->seq_client < 0) {
                         kfree(client);
+                        mutex_unlock(&register_mutex);
+                        kfree(info);
                         return -ENOMEM;
                 }
@@ -400 +405 @@
         if (newclient)
                 synths[card->number] = client;
+        mutex_unlock(&register_mutex);
+        kfree(info);
+        kfree(port);
         return 0;       /* success */
 
@@ -412 +420 @@
                 kfree(client);
         }
+        kfree(info);
+        kfree(port);
+        mutex_unlock(&register_mutex);
         return -ENOMEM;
 }
@@ -425 +436 @@
         int device = dev->device, p, ports;
         
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         client = synths[card->number];
-        if (client == NULL || client->ports[device] == NULL)
+        if (client == NULL || client->ports[device] == NULL) {
+                mutex_unlock(&register_mutex);
                 return -ENODEV;
+        }
         ports = client->ports_per_device[device];
         client->ports_per_device[device] = 0;
@@ -442 +455 @@
                 kfree(client);
         }
+        mutex_unlock(&register_mutex);
         return 0;
 }

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_midi_event.c ¶

@@ -145 +145 @@
 void snd_midi_event_reset_encode(struct snd_midi_event *dev)
 {
-        guard(spinlock_irqsave)(&dev->lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->lock, flags);
         reset_encode(dev);
+        spin_unlock_irqrestore(&dev->lock, flags);
 }
 EXPORT_SYMBOL(snd_midi_event_reset_encode);
@@ -152 +155 @@
 void snd_midi_event_reset_decode(struct snd_midi_event *dev)
 {
-        guard(spinlock_irqsave)(&dev->lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->lock, flags);
         dev->lastcmd = 0xff;
+        spin_unlock_irqrestore(&dev->lock, flags);
 }
 EXPORT_SYMBOL(snd_midi_event_reset_decode);
@@ -172 +178 @@
 {
         bool rc = false;
+        unsigned long flags;
 
         if (c >= MIDI_CMD_COMMON_CLOCK) {
@@ -181 +188 @@
         }
 
-        guard(spinlock_irqsave)(&dev->lock);
+        spin_lock_irqsave(&dev->lock, flags);
         if ((c & 0x80) &&
             (c != MIDI_CMD_COMMON_SYSEX_END || dev->type != ST_SYSEX)) {
@@ -230 +237 @@
         }
 
+        spin_unlock_irqrestore(&dev->lock, flags);
         return rc;
 }

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_ports.c ¶

@@ -49 +49 @@
         if (client == NULL)
                 return NULL;
-        guard(read_lock)(&client->ports_lock);
+        read_lock(&client->ports_lock);
         list_for_each_entry(port, &client->ports_list_head, list, struct snd_seq_client_port) {
                 if (port->addr.port == num) {
@@ -58 +58 @@
                 }
         }
+        read_unlock(&client->ports_lock);
         return NULL;            /* not found */
 }
@@ -72 +73 @@
         num = pinfo->addr.port;
         found = NULL;
-        guard(read_lock)(&client->ports_lock);
+        read_lock(&client->ports_lock);
         list_for_each_entry(port, &client->ports_list_head, list, struct snd_seq_client_port) {
                 if ((port->capability & SNDRV_SEQ_PORT_CAP_INACTIVE) &&
@@ -92 +93 @@
                         snd_use_lock_use(&found->use_lock);
         }
+        read_unlock(&client->ports_lock);
         return found;
 }
@@ -143 +145 @@
 
         num = max(port, 0);
-        guard(mutex)(&client->ports_mutex);
-        guard(write_lock_irq)(&client->ports_lock);
+        mutex_lock(&client->ports_mutex);
+        write_lock_irq(&client->ports_lock);
         list_for_each_entry(p, &client->ports_list_head, list, struct snd_seq_client_port) {
                 if (p->addr.port == port) {
                         kfree(new_port);
-                        return -EBUSY;
+                        num = -EBUSY;
+                        goto unlock;
                 }
                 if (p->addr.port > num)
@@ -161 +164 @@
         sprintf(new_port->name, "port-%d", num);
         *port_ret = new_port;
+ unlock:
+        write_unlock_irq(&client->ports_lock);
+        mutex_unlock(&client->ports_mutex);
 
         return num;
@@ -275 +281 @@
         struct snd_seq_client_port *found = NULL, *p;
 
-        scoped_guard(mutex, &client->ports_mutex) {
-                guard(write_lock_irq)(&client->ports_lock);
+        mutex_lock(&client->ports_mutex);
+        write_lock_irq(&client->ports_lock);
         list_for_each_entry(p, &client->ports_list_head, list, struct snd_seq_client_port) {
                 if (p->addr.port == port) {
@@ -286 +292 @@
                 }
         }
-        }
+        write_unlock_irq(&client->ports_lock);
+        mutex_unlock(&client->ports_mutex);
         if (found)
                 return port_delete(client, found);
@@ -302 +309 @@
          * clear the port list in the client data.
          */
-        guard(mutex)(&client->ports_mutex);
-        scoped_guard(write_lock_irq, &client->ports_lock) {
+        mutex_lock(&client->ports_mutex);
+        write_lock_irq(&client->ports_lock);
         if (! list_empty(&client->ports_list_head)) {
                 list_add(&deleted_list, &client->ports_list_head);
@@ -311 +318 @@
         }
         client->num_ports = 0;
-        }
+        write_unlock_irq(&client->ports_lock);
 
         /* remove each port in deleted_list */
@@ -319 +326 @@
                 port_delete(client, port);
         }
+        mutex_unlock(&client->ports_mutex);
         return 0;
 }
@@ -503 +511 @@
 
         grp = is_src ? &port->c_src : &port->c_dest;
-        guard(rwsem_write)(&grp->list_mutex);
+        err = -EBUSY;
+        down_write(&grp->list_mutex);
         if (exclusive) {
                 if (!list_empty(&grp->list_head))
-                        return -EBUSY;
+                        goto __error;
         } else {
                 if (grp->exclusive)
-                        return -EBUSY;
+                        goto __error;
                 /* check whether already exists */
                 list_for_each(p, &grp->list_head) {
                         s = get_subscriber(p, is_src);
                         if (match_subs_info(&subs->info, &s->info))
-                                return -EBUSY;
+                                goto __error;
                 }
         }
@@ -521 +530 @@
         if (err < 0) {
                 grp->exclusive = 0;
-                return err;
+                goto __error;
         }
 
         /* add to list */
-        guard(write_lock_irq)(&grp->list_lock);
+        write_lock_irq(&grp->list_lock);
         if (is_src)
                 list_add_tail(&subs->src_list, &grp->list_head);
@@ -532 +541 @@
         grp->exclusive = exclusive;
         atomic_inc(&subs->ref_count);
-
-        return 0;
+        write_unlock_irq(&grp->list_lock);
+        err = 0;
+
+ __error:
+        up_write(&grp->list_mutex);
+        return err;
 }
 
@@ -548 +561 @@
         grp = is_src ? &port->c_src : &port->c_dest;
         list = is_src ? &subs->src_list : &subs->dest_list;
-        scoped_guard(write_lock_irq, &grp->list_lock) {
+        write_lock_irq(&grp->list_lock);
         empty = list_empty(list);
         if (!empty)
                 list_del_init(list);
         grp->exclusive = 0;
-        }
+        write_unlock_irq(&grp->list_lock);
 
         if (!empty)
@@ -567 +580 @@
 
         grp = is_src ? &port->c_src : &port->c_dest;
-        guard(rwsem_write)(&grp->list_mutex);
+        down_write(&grp->list_mutex);
         __delete_and_unsubscribe_port(client, port, subs, is_src, ack);
+        up_write(&grp->list_mutex);
 }
 
@@ -630 +644 @@
          * deletions
          */
-        scoped_guard(rwsem_write, &dest->list_mutex) {
+        down_write(&dest->list_mutex);
         /* look for the connection */
         list_for_each_entry(subs, &dest->list_head, dest_list, struct snd_seq_subscribers) {
@@ -639 +653 @@
                         err = 0;
                         break;
-                }
-        }
-        }
+                }
+        }
+        up_write(&dest->list_mutex);
         if (err < 0)
                 return err;
@@ -660 +674 @@
         int err = -ENOENT;
 
-        guard(rwsem_read)(&src_grp->list_mutex);
+        down_read(&src_grp->list_mutex);
         list_for_each_entry(s, &src_grp->list_head, src_list, struct snd_seq_subscribers) {
                 if (addr_match(dest_addr, &s->info.dest)) {
@@ -668 +682 @@
                 }
         }
+        up_read(&src_grp->list_mutex);
         return err;
 }

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_prioq.c ¶

@@ -133 +133 @@
 {
         struct snd_seq_event_cell *cur, *prev;
+        unsigned long flags;
         int count;
         int prior;
@@ -142 +143 @@
         prior = (cell->event.flags & SNDRV_SEQ_PRIORITY_MASK);
 
-        guard(spinlock_irqsave)(&f->lock);
+        spin_lock_irqsave(&f->lock, flags);
 
         /* check if this element needs to inserted at the end (ie. ordered 
@@ -154 +155 @@
                         cell->next = NULL;
                         f->cells++;
+                        spin_unlock_irqrestore(&f->lock, flags);
                         return 0;
                 }
@@ -179 +181 @@
                 if (! --count) {
                         pr_err("ALSA: seq: cannot find a pointer.. infinite loop?\n");
+                        spin_unlock_irqrestore(&f->lock, flags);
                         return -EINVAL;
                 }
@@ -193 +196 @@
                 f->tail = cell;
         f->cells++;
+        spin_unlock_irqrestore(&f->lock, flags);
         return 0;
 }
@@ -210 +214 @@
 {
         struct snd_seq_event_cell *cell;
+        unsigned long flags;
 
         if (f == NULL) {
@@ -215 +220 @@
                 return NULL;
         }
-
-        guard(spinlock_irqsave)(&f->lock);
+        spin_lock_irqsave(&f->lock, flags);
+
         cell = f->head;
         if (cell && current_time && !event_is_ready(&cell->event, current_time))
@@ -231 +236 @@
         }
 
+        spin_unlock_irqrestore(&f->lock, flags);
         return cell;
 }
@@ -251 +257 @@
 {
         register struct snd_seq_event_cell *cell, *next;
+        unsigned long flags;
         struct snd_seq_event_cell *prev = NULL;
         struct snd_seq_event_cell *freefirst = NULL, *freeprev = NULL, *freenext;
 
         /* collect all removed cells */
-        scoped_guard(spinlock_irqsave, &f->lock) {
-                for (cell = f->head; cell; cell = next) {
+        spin_lock_irqsave(&f->lock, flags);
+        for (cell = f->head; cell; cell = next) {
                 next = cell->next;
-                        if (!match(cell, arg)) {
-                                prev = cell;
-                                continue;
-                        }
+                if (!match(cell, arg)) {
+                        prev = cell;
+                        continue;
+                }
 
                         /* remove cell from prioq */
-                        if (cell == f->head)
-                                f->head = cell->next;
-                        else
-                                prev->next = cell->next;
-                        if (cell == f->tail)
-                                f->tail = cell->next;
-                        f->cells--;
-
-                        /* add cell to free list */
-                        cell->next = NULL;
-                        if (freefirst == NULL)
-                                freefirst = cell;
-                        else
-                                freeprev->next = cell;
-                        freeprev = cell;
-                }
-        }
+                if (cell == f->head)
+                        f->head = cell->next;
+                else
+                        prev->next = cell->next;
+                if (cell == f->tail)
+                        f->tail = cell->next;
+                f->cells--;
+
+                /* add cell to free list */
+                cell->next = NULL;
+                if (freefirst == NULL)
+                        freefirst = cell;
+                else
+                        freeprev->next = cell;
+                freeprev = cell;
+        }
+        spin_unlock_irqrestore(&f->lock, flags);
 
         /* remove selected cells */
@@ -321 +328 @@
 void snd_seq_prioq_leave(struct snd_seq_prioq *f, int client, int timestamp)
 {
-        struct prioq_match_arg arg = { client, timestamp };
-
-        return prioq_remove_cells(f, prioq_match, &arg);
+        struct prioq_match_arg arg;
+        arg.client = client;
+        arg.timestamp = timestamp;
+
+        prioq_remove_cells(f, prioq_match, &arg);
 }
 
@@ -395 +404 @@
                                  struct snd_seq_remove_events *info)
 {
-        struct prioq_remove_match_arg arg = { client, info };
-
-        return prioq_remove_cells(f, prioq_remove_match, &arg);
-                        }
+        struct prioq_remove_match_arg arg;
+        arg.client = client;
+        arg.info = info;
+
+        prioq_remove_cells(f, prioq_remove_match, &arg);
+}

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_queue.c ¶

@@ -51 +51 @@
 {
         int i;
-
-        guard(spinlock_irqsave)(&queue_list_lock);
+        unsigned long flags;
+ 
+        spin_lock_irqsave(&queue_list_lock, flags);
         for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
                 if (! queue_list[i]) {
@@ -58 +59 @@
                         q->queue = i;
                         num_queues++;
+                        spin_unlock_irqrestore(&queue_list_lock, flags);
                         return i;
                 }
         }
+        spin_unlock_irqrestore(&queue_list_lock, flags);
         return -1;
 }
@@ -67 +70 @@
 {
         struct snd_seq_queue *q;
-
-        guard(spinlock_irqsave)(&queue_list_lock);
+        unsigned long flags;
+ 
+        spin_lock_irqsave(&queue_list_lock, flags);
         q = queue_list[id];
         if (q) {
-                guard(spinlock)(&q->owner_lock);
+                spin_lock(&q->owner_lock);
                 if (q->owner == client) {
                         /* found */
+                        spin_unlock(&q->owner_lock);
                         q->klocked = 1;
                         queue_list[id] = NULL;
                         num_queues--;
+                        spin_unlock_irqrestore(&queue_list_lock, flags);
                         return q;
                 }
-        }
+                spin_unlock(&q->owner_lock);
+        }
+        spin_unlock_irqrestore(&queue_list_lock, flags);
         return NULL;
 }
@@ -196 +204 @@
 {
         struct snd_seq_queue *q;
+        unsigned long flags;
 
         if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES)
                 return NULL;
-        guard(spinlock_irqsave)(&queue_list_lock);
+        spin_lock_irqsave(&queue_list_lock, flags);
         q = queue_list[queueid];
         if (q)
                 snd_use_lock_use(&q->use_lock);
+        spin_unlock_irqrestore(&queue_list_lock, flags);
         return q;
 }
@@ -230 +240 @@
 void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop)
 {
+        unsigned long flags;
         struct snd_seq_event_cell *cell;
         snd_seq_tick_time_t cur_tick;
@@ -239 +250 @@
 
         /* make this function non-reentrant */
-        scoped_guard(spinlock_irqsave, &q->check_lock) {
+        spin_lock_irqsave(&q->check_lock, flags);
         if (q->check_blocked) {
                 q->check_again = 1;
+                spin_unlock_irqrestore(&q->check_lock, flags);
                 return;         /* other thread is already checking queues */
         }
         q->check_blocked = 1;
-        }
+        spin_unlock_irqrestore(&q->check_lock, flags);
 
       __again:
@@ -272 +284 @@
  out:
         /* free lock */
-        scoped_guard(spinlock_irqsave, &q->check_lock) {
+        spin_lock_irqsave(&q->check_lock, flags);
         if (q->check_again) {
                 q->check_again = 0;
-                        if (processed < MAX_CELL_PROCESSES_IN_QUEUE)
+                if (processed < MAX_CELL_PROCESSES_IN_QUEUE) {
+                        spin_unlock_irqrestore(&q->check_lock, flags);
                         goto __again;
                 }
+        }
         q->check_blocked = 0;
-        }
+        spin_unlock_irqrestore(&q->check_lock, flags);
 }
 
@@ -348 +362 @@
 static int queue_access_lock(struct snd_seq_queue *q, int client)
 {
+        unsigned long flags;
         int access_ok;
         
-        guard(spinlock_irqsave)(&q->owner_lock);
+        spin_lock_irqsave(&q->owner_lock, flags);
         access_ok = check_access(q, client);
         if (access_ok)
                 q->klocked = 1;
+        spin_unlock_irqrestore(&q->owner_lock, flags);
         return access_ok;
 }
@@ -360 +376 @@
 static inline void queue_access_unlock(struct snd_seq_queue *q)
 {
-        guard(spinlock_irqsave)(&q->owner_lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&q->owner_lock, flags);
         q->klocked = 0;
+        spin_unlock_irqrestore(&q->owner_lock, flags);
 }
 
@@ -369 +388 @@
         struct snd_seq_queue *q = queueptr(queueid);
         int access_ok;
+        unsigned long flags;
 
         if (! q)
                 return 0;
-        scoped_guard(spinlock_irqsave, &q->owner_lock)
+        spin_lock_irqsave(&q->owner_lock, flags);
         access_ok = check_access(q, client);
+        spin_unlock_irqrestore(&q->owner_lock, flags);
         queuefree(q);
         return access_ok;
@@ -386 +407 @@
 {
         struct snd_seq_queue *q = queueptr(queueid);
+        unsigned long flags;
 
         if (q == NULL)
@@ -395 +417 @@
         }
 
-        scoped_guard(spinlock_irqsave, &q->owner_lock) {
+        spin_lock_irqsave(&q->owner_lock, flags);
         q->locked = locked ? 1 : 0;
         q->owner = client;
-        }
+        spin_unlock_irqrestore(&q->owner_lock, flags);
         queue_access_unlock(q);
         queuefree(q);
@@ -730 +752 @@
                         bpm = 0;
 
-                scoped_guard(spinlock_irq, &q->owner_lock) {
+                spin_lock_irq(&q->owner_lock);
                 locked = q->locked;
                 owner = q->owner;
-                }
+                spin_unlock_irq(&q->owner_lock);
 
                 snd_iprintf(buffer, "queue %d: [%s]\n", q->queue, q->name);

GPL/branches/uniaud32-exp/alsa-kernel/core/seq/seq_timer.c ¶

@@ -79 +79 @@
 void snd_seq_timer_defaults(struct snd_seq_timer * tmr)
 {
-        guard(spinlock_irqsave)(&tmr->lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&tmr->lock, flags);
         /* setup defaults */
         tmr->ppq = 96;          /* 96 PPQ */
@@ -96 +98 @@
 
         tmr->skew = tmr->skew_base = SKEW_BASE;
+        spin_unlock_irqrestore(&tmr->lock, flags);
 }
 
@@ -110 +113 @@
 void snd_seq_timer_reset(struct snd_seq_timer *tmr)
 {
-        guard(spinlock_irqsave)(&tmr->lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&tmr->lock, flags);
         seq_timer_reset(tmr);
+        spin_unlock_irqrestore(&tmr->lock, flags);
 }
 
@@ -120 +126 @@
                                     unsigned long ticks)
 {
+        unsigned long flags;
         struct snd_seq_queue *q = timeri->callback_data;
         struct snd_seq_timer *tmr;
@@ -129 +136 @@
                 return;
 
-        scoped_guard(spinlock_irqsave, &tmr->lock) {
-                if (!tmr->running)
+        spin_lock_irqsave(&tmr->lock, flags);
+        if (!tmr->running) {
+                spin_unlock_irqrestore(&tmr->lock, flags);
                 return;
+        }
 
         resolution *= ticks;
@@ -139 +148 @@
                         (((resolution & 0xffff) * tmr->skew) >> 16);
         }
-
+ 
         /* update timer */
         snd_seq_inc_time_nsec(&tmr->cur_time, resolution);
@@ -148 +157 @@
         /* register actual time of this timer update */
         ktime_get_ts64(&tmr->last_update);
-        }
+
+        spin_unlock_irqrestore(&tmr->lock, flags);
 
         /* check queues and dispatch events */
@@ -157 +167 @@
 int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo)
 {
+        unsigned long flags;
+
         if (snd_BUG_ON(!tmr))
                 return -EINVAL;
         if (tempo <= 0)
                 return -EINVAL;
-        guard(spinlock_irqsave)(&tmr->lock);
+        spin_lock_irqsave(&tmr->lock, flags);
         if ((unsigned int)tempo != tmr->tempo) {
                 tmr->tempo = tempo;
                 snd_seq_timer_set_tick_resolution(tmr);
         }
+        spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
 }
@@ -174 +187 @@
 {
         int changed;
+        unsigned long flags;
 
         if (snd_BUG_ON(!tmr))
@@ -182 +196 @@
         if (tempo_base && tempo_base != 10 && tempo_base != 1000)
                 return -EINVAL;
-        guard(spinlock_irqsave)(&tmr->lock);
+        spin_lock_irqsave(&tmr->lock, flags);
         if (tmr->running && (ppq != tmr->ppq)) {
                 /* refuse to change ppq on running timers */
                 /* because it will upset the song position (ticks) */
+                spin_unlock_irqrestore(&tmr->lock, flags);
                 pr_debug("ALSA: seq: cannot change ppq of a running timer\n");
                 return -EBUSY;
@@ -195 +210 @@
         if (changed)
                 snd_seq_timer_set_tick_resolution(tmr);
+        spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
 }
@@ -202 +218 @@
                                     snd_seq_tick_time_t position)
 {
-        if (snd_BUG_ON(!tmr))
-                return -EINVAL;
-
-        guard(spinlock_irqsave)(&tmr->lock);
+        unsigned long flags;
+
+        if (snd_BUG_ON(!tmr))
+                return -EINVAL;
+
+        spin_lock_irqsave(&tmr->lock, flags);
         tmr->tick.cur_tick = position;
         tmr->tick.fraction = 0;
+        spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
 }
@@ -215 +234 @@
                                     snd_seq_real_time_t position)
 {
+        unsigned long flags;
+
         if (snd_BUG_ON(!tmr))
                 return -EINVAL;
 
         snd_seq_sanity_real_time(&position);
-        guard(spinlock_irqsave)(&tmr->lock);
+        spin_lock_irqsave(&tmr->lock, flags);
         tmr->cur_time = position;
+        spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
 }
@@ -228 +250 @@
                            unsigned int base)
 {
+        unsigned long flags;
+
         if (snd_BUG_ON(!tmr))
                 return -EINVAL;
@@ -236 +260 @@
                 return -EINVAL;
         }
-        guard(spinlock_irqsave)(&tmr->lock);
+        spin_lock_irqsave(&tmr->lock, flags);
         tmr->skew = skew;
+        spin_unlock_irqrestore(&tmr->lock, flags);
         return 0;
 }
@@ -282 +307 @@
                 return err;
         }
-        scoped_guard(spinlock_irq, &tmr->lock) {
+        spin_lock_irq(&tmr->lock);
         if (tmr->timeri)
                 err = -EBUSY;
         else
                 tmr->timeri = t;
-        }
+        spin_unlock_irq(&tmr->lock);
         if (err < 0) {
                 snd_timer_close(t);
@@ -304 +329 @@
         if (snd_BUG_ON(!tmr))
                 return -EINVAL;
-        scoped_guard(spinlock_irq, &tmr->lock) {
+        spin_lock_irq(&tmr->lock);
         t = tmr->timeri;
         tmr->timeri = NULL;
-        }
+        spin_unlock_irq(&tmr->lock);
         if (t) {
                 snd_timer_close(t);
@@ -328 +353 @@
 int snd_seq_timer_stop(struct snd_seq_timer *tmr)
 {
-        guard(spinlock_irqsave)(&tmr->lock);
-        return seq_timer_stop(tmr);
+        unsigned long flags;
+        int err;
+
+        spin_lock_irqsave(&tmr->lock, flags);
+        err = seq_timer_stop(tmr);
+        spin_unlock_irqrestore(&tmr->lock, flags);
+        return err;
 }
 
@@ -379 +409 @@
 int snd_seq_timer_start(struct snd_seq_timer *tmr)
 {
-        guard(spinlock_irqsave)(&tmr->lock);
-        return seq_timer_start(tmr);
+        unsigned long flags;
+        int err;
+
+        spin_lock_irqsave(&tmr->lock, flags);
+        err = seq_timer_start(tmr);
+        spin_unlock_irqrestore(&tmr->lock, flags);
+        return err;
 }
 
@@ -402 +437 @@
 int snd_seq_timer_continue(struct snd_seq_timer *tmr)
 {
-        guard(spinlock_irqsave)(&tmr->lock);
-        return seq_timer_continue(tmr);
+        unsigned long flags;
+        int err;
+
+        spin_lock_irqsave(&tmr->lock, flags);
+        err = seq_timer_continue(tmr);
+        spin_unlock_irqrestore(&tmr->lock, flags);
+        return err;
 }
 
@@ -411 +451 @@
 {
         snd_seq_real_time_t cur_time;
-
-        guard(spinlock_irqsave)(&tmr->lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&tmr->lock, flags);
         cur_time = tmr->cur_time;
         if (adjust_ktime && tmr->running) {
@@ -424 +465 @@
         }
 
+        spin_unlock_irqrestore(&tmr->lock, flags);
         return cur_time;        
 }
@@ -431 +473 @@
 snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr)
 {
-        guard(spinlock_irqsave)(&tmr->lock);
-        return tmr->tick.cur_tick;
+        snd_seq_tick_time_t cur_tick;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tmr->lock, flags);
+        cur_tick = tmr->tick.cur_tick;
+        spin_unlock_irqrestore(&tmr->lock, flags);
+        return cur_tick;
 }
 
@@ -451 +498 @@
                 if (q == NULL)
                         continue;
-                scoped_guard(mutex, &q->timer_mutex) {
+                mutex_lock(&q->timer_mutex);
                 tmr = q->timer;
                 if (!tmr)
-                                break;
+                        goto unlock;
                 ti = tmr->timeri;
                 if (!ti)
-                                break;
+                        goto unlock;
                 snd_iprintf(buffer, "Timer for queue %i : %s\n", q->queue, ti->timer->name);
                 resolution = snd_timer_resolution(ti) * tmr->ticks;
                 snd_iprintf(buffer, "  Period time : %lu.%09lu\n", resolution / 1000000000, resolution % 1000000000);
                 snd_iprintf(buffer, "  Skew : %u / %u\n", tmr->skew, tmr->skew_base);
-                }
+unlock:
+                mutex_unlock(&q->timer_mutex);
                 queuefree(q);
         }

GPL/branches/uniaud32-exp/alsa-kernel/core/sound.c ¶

@@ -103 +103 @@
         if (minor >= ARRAY_SIZE(snd_minors))
                 return NULL;
-        guard(mutex)(&sound_mutex);
+        mutex_lock(&sound_mutex);
         mreg = snd_minors[minor];
         if (mreg && mreg->type == type) {
@@ -111 +111 @@
         } else
                 private_data = NULL;
+        mutex_unlock(&sound_mutex);
         return private_data;
 }
@@ -149 +150 @@
         if (minor >= ARRAY_SIZE(snd_minors))
                 return -ENODEV;
-        scoped_guard(mutex, &sound_mutex) {
+        mutex_lock(&sound_mutex);
         mptr = snd_minors[minor];
         if (mptr == NULL) {
                 mptr = autoload_device(minor);
-                        if (!mptr)
+                if (!mptr) {
+                        mutex_unlock(&sound_mutex);
                         return -ENODEV;
                 }
 #ifndef TARGET_OS2 //code below from 3.13 crashes, using 3.8 code for now
         new_fops = fops_get(mptr->f_ops);
+        mutex_unlock(&sound_mutex);
         }
         if (!new_fops)
@@ -168 +171 @@
 #else
         new_fops = file->f_op;
+        mutex_unlock(&sound_mutex);
         }
         file->f_op = fops_get(mptr->f_ops);
@@ -291 +295 @@
         preg->private_data = private_data;
         preg->card_ptr = card;
-        guard(mutex)(&sound_mutex);
+        mutex_lock(&sound_mutex);
         minor = snd_find_free_minor(type, card, dev);
         if (minor < 0) {
@@ -306 +310 @@
         snd_minors[minor] = preg;
  error:
+        mutex_unlock(&sound_mutex);
         if (err < 0)
                 kfree(preg);
@@ -326 +331 @@
         struct snd_minor *preg;
 
-        guard(mutex)(&sound_mutex);
+        mutex_lock(&sound_mutex);
         for (minor = 0; minor < ARRAY_SIZE(snd_minors); ++minor) {
                 preg = snd_minors[minor];
@@ -336 +341 @@
                 }
         }
+        mutex_unlock(&sound_mutex);
         if (minor >= ARRAY_SIZE(snd_minors))
                 return -ENOENT;
@@ -375 +381 @@
         struct snd_minor *mptr;
 
-        guard(mutex)(&sound_mutex);
+        mutex_lock(&sound_mutex);
         for (minor = 0; minor < SNDRV_OS_MINORS; ++minor) {
                 mptr = snd_minors[minor];
@@ -393 +399 @@
                                     snd_device_type_name(mptr->type));
         }
+        mutex_unlock(&sound_mutex);
 }
 

GPL/branches/uniaud32-exp/alsa-kernel/core/sound_oss.c ¶

@@ -34 +34 @@
         if (minor >= ARRAY_SIZE(snd_oss_minors))
                 return NULL;
-        guard(mutex)(&sound_oss_mutex);
+        mutex_lock(&sound_oss_mutex);
         mreg = snd_oss_minors[minor];
         if (mreg && mreg->type == type) {
@@ -42 +42 @@
         } else
                 private_data = NULL;
+        mutex_unlock(&sound_oss_mutex);
         return private_data;
 }
@@ -110 +111 @@
         preg->private_data = private_data;
         preg->card_ptr = card;
-        guard(mutex)(&sound_oss_mutex);
+        mutex_lock(&sound_oss_mutex);
         snd_oss_minors[minor] = preg;
         minor_unit = SNDRV_MINOR_OSS_DEVICE(minor);
@@ -136 +137 @@
         }
 #endif
+        mutex_unlock(&sound_oss_mutex);
         return 0;
 
@@ -145 +147 @@
                 unregister_sound_special(register1);
         snd_oss_minors[minor] = NULL;
+        mutex_unlock(&sound_oss_mutex);
         kfree(preg);
         return -EBUSY;
@@ -162 +165 @@
         if (minor < 0)
                 return minor;
-        guard(mutex)(&sound_oss_mutex);
+        mutex_lock(&sound_oss_mutex);
         mptr = snd_oss_minors[minor];
-        if (mptr == NULL)
+        if (mptr == NULL) {
+                mutex_unlock(&sound_oss_mutex);
                 return -ENOENT;
+        }
         switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
         case SNDRV_MINOR_OSS_PCM:
@@ -180 +185 @@
                 snd_oss_minors[track2] = NULL;
         snd_oss_minors[minor] = NULL;
+        mutex_unlock(&sound_oss_mutex);
 
         /* call unregister_sound_special() outside sound_oss_mutex;
@@ -223 +229 @@
         struct snd_minor *mptr;
 
-        guard(mutex)(&sound_oss_mutex);
+        mutex_lock(&sound_oss_mutex);
         for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) {
                 mptr = snd_oss_minors[minor];
@@ -236 +242 @@
                                     snd_oss_device_type_name(mptr->type));
         }
+        mutex_unlock(&sound_oss_mutex);
 }
 

GPL/branches/uniaud32-exp/alsa-kernel/core/timer.c ¶

@@ -14 +14 @@
 #include <linux/string.h>
 #include <linux/sched/signal.h>
+#ifndef TARGET_OS2
 #include <linux/anon_inodes.h>
 #include <linux/idr.h>
+#endif
 #include <sound/core.h>
 #include <sound/timer.h>
@@ -238 +240 @@
         list_move_tail(&slave->open_list, &master->slave_list_head);
         master->timer->num_instances++;
-        guard(spinlock_irq)(&slave_active_lock);
-        guard(spinlock)(&master->timer->lock);
+        spin_lock_irq(&slave_active_lock);
+        spin_lock(&master->timer->lock);
         slave->master = master;
         slave->timer = master->timer;
         if (slave->flags & SNDRV_TIMER_IFLG_RUNNING)
                 list_add_tail(&slave->active_list, &master->slave_active_head);
+        spin_unlock(&master->timer->lock);
+        spin_unlock_irq(&slave_active_lock);
         return 1;
 }
@@ -400 +404 @@
         struct snd_timer_instance *slave, *tmp;
 
-        guard(spinlock_irq)(&slave_active_lock);
-        guard(spinlock)(&timer->lock);
+        spin_lock_irq(&slave_active_lock);
+        spin_lock(&timer->lock);
         timeri->timer = NULL;
-        list_for_each_entry_safe(slave, tmp, &timeri->slave_list_head, open_list) {
+        list_for_each_entry_safe(slave, tmp, &timeri->slave_list_head, open_list, struct snd_timer_instance) {
                 list_move_tail(&slave->open_list, &snd_timer_slave_list);
                 timer->num_instances--;
@@ -411 +415 @@
                 list_del_init(&slave->active_list);
         }
+        spin_unlock_irq(&slave_active_lock);
+        spin_unlock(&timer->lock);
 }
 
@@ -421 +427 @@
 {
         struct snd_timer *timer = timeri->timer;
+        struct snd_timer_instance *slave, *tmp;
 
         if (timer) {
-                guard(spinlock_irq)(&timer->lock);
+                spin_lock_irq(&timer->lock);
                 timeri->flags |= SNDRV_TIMER_IFLG_DEAD;
+                spin_unlock_irq(&timer->lock);
         }
 
@@ -449 +457 @@
                 remove_slave_links(timeri, timer);
 
+                /* slave doesn't need to release timer resources below */
+                if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
+                        timer = NULL;
+        }
+
         if (timer) {
                 if (list_empty(&timer->open_list_head) && timer->hw.close)
@@ -469 +482 @@
                 return;
 
-        scoped_guard(mutex, &register_mutex)
+        mutex_lock(&register_mutex);
         snd_timer_close_locked(timeri, &card_dev_to_put);
+        mutex_unlock(&register_mutex);
         /* put_device() is called after unlock for avoiding deadlock */
         if (card_dev_to_put)
@@ -489 +503 @@
         struct snd_timer * timer;
         unsigned long ret = 0;
+        unsigned long flags;
 
         if (timeri == NULL)
@@ -494 +509 @@
         timer = timeri->timer;
         if (timer) {
-                guard(spinlock_irqsave)(&timer->lock);
+                spin_lock_irqsave(&timer->lock, flags);
                 ret = snd_timer_hw_resolution(timer);
+                spin_unlock_irqrestore(&timer->lock, flags);
         }
         return ret;
@@ -539 +555 @@
         struct snd_timer *timer;
         int result;
+        unsigned long flags;
 
         timer = timeri->timer;
         if (!timer)
                 return -EINVAL;
-
-        guard(spinlock_irqsave)(&timer->lock);
-        if (timeri->flags & SNDRV_TIMER_IFLG_DEAD)
-                return -EINVAL;
-        if (timer->card && timer->card->shutdown)
-                return -ENODEV;
+        spin_lock_irqsave(&timer->lock, flags);
+        if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) {
+                result = -EINVAL;
+                goto unlock;
+        }
+        if (timer->card && timer->card->shutdown) {
+                result = -ENODEV;
+                goto unlock;
+        }
         if (timeri->flags & (SNDRV_TIMER_IFLG_RUNNING |
-                             SNDRV_TIMER_IFLG_START))
-                return -EBUSY;
+                             SNDRV_TIMER_IFLG_START)) {
+                result = -EBUSY;
+                goto unlock;
+        }
 
         /* check the actual time for the start tick;
@@ -557 +579 @@
          */
         if (start && !(timer->hw.flags & SNDRV_TIMER_HW_SLAVE)) {
-                if ((u64)snd_timer_hw_resolution(timer) * ticks < 100000)
-                        return -EINVAL;
+                if ((u64)snd_timer_hw_resolution(timer) * ticks < 100000) {
+                        result = -EINVAL;
+                        goto unlock;
+                }
         }
 
@@ -585 +609 @@
         snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START :
                           SNDRV_TIMER_EVENT_CONTINUE);
+ unlock:
+        spin_unlock_irqrestore(&timer->lock, flags);
         return result;
 }
@@ -592 +618 @@
                                  bool start)
 {
-        guard(spinlock_irqsave)(&slave_active_lock);
-        if (timeri->flags & SNDRV_TIMER_IFLG_DEAD)
-                return -EINVAL;
-        if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING)
-                return -EBUSY;
+        unsigned long flags;
+        int err;
+
+        spin_lock_irqsave(&slave_active_lock, flags);
+        if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) {
+                err = -EINVAL;
+                goto unlock;
+        }
+        if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING) {
+                err = -EBUSY;
+                goto unlock;
+        }
         timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
         if (timeri->master && timeri->timer) {
-                guard(spinlock)(&timeri->timer->lock);
+                spin_lock(&timeri->timer->lock);
                 list_add_tail(&timeri->active_list,
                               &timeri->master->slave_active_head);
                 snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START :
                                   SNDRV_TIMER_EVENT_CONTINUE);
-        }
-        return 1; /* delayed start */
+                spin_unlock(&timeri->timer->lock);
+        }
+        err = 1; /* delayed start */
+ unlock:
+        spin_unlock_irqrestore(&slave_active_lock, flags);
+        return err;
 }
 
@@ -612 +649 @@
 {
         struct snd_timer *timer;
+        int result = 0;
+        unsigned long flags;
 
         timer = timeri->timer;
         if (!timer)
                 return -EINVAL;
-        guard(spinlock_irqsave)(&timer->lock);
+        spin_lock_irqsave(&timer->lock, flags);
         list_del_init(&timeri->ack_list);
         list_del_init(&timeri->active_list);
         if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING |
-                               SNDRV_TIMER_IFLG_START)))
-                return -EBUSY;
+                               SNDRV_TIMER_IFLG_START))) {
+                result = -EBUSY;
+                goto unlock;
+        }
         if (timer->card && timer->card->shutdown)
-                return 0;
+                goto unlock;
         if (stop) {
                 timeri->cticks = timeri->ticks;
@@ -647 +688 @@
         snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
                           SNDRV_TIMER_EVENT_PAUSE);
-        return 0;
+ unlock:
+        spin_unlock_irqrestore(&timer->lock, flags);
+        return result;
 }
 
@@ -653 +696 @@
 static int snd_timer_stop_slave(struct snd_timer_instance *timeri, bool stop)
 {
+        unsigned long flags;
         bool running;
 
-        guard(spinlock_irqsave)(&slave_active_lock);
+        spin_lock_irqsave(&slave_active_lock, flags);
         running = timeri->flags & SNDRV_TIMER_IFLG_RUNNING;
         timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
         if (timeri->timer) {
-                guard(spinlock)(&timeri->timer->lock);
+                spin_lock(&timeri->timer->lock);
                 list_del_init(&timeri->ack_list);
                 list_del_init(&timeri->active_list);
@@ -665 +709 @@
                         snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP :
                                           SNDRV_TIMER_EVENT_PAUSE);
-        }
+                spin_unlock(&timeri->timer->lock);
+        }
+        spin_unlock_irqrestore(&slave_active_lock, flags);
         return running ? 0 : -EBUSY;
 }
@@ -790 +836 @@
                                       struct list_head *head)
 {
-        guard(spinlock_irqsave)(&timer->lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&timer->lock, flags);
         while (!list_empty(head))
                 list_del_init(head->next);
+        spin_unlock_irqrestore(&timer->lock, flags);
 }
 
@@ -806 +855 @@
 {
         struct snd_timer *timer = container_of(work, struct snd_timer, task_work);
+        unsigned long flags;
 
         if (timer->card && timer->card->shutdown) {
@@ -812 +862 @@
         }
 
-        guard(spinlock_irqsave)(&timer->lock);
+        spin_lock_irqsave(&timer->lock, flags);
         snd_timer_process_callbacks(timer, &timer->sack_list_head);
+        spin_unlock_irqrestore(&timer->lock, flags);
 }
 
@@ -827 +878 @@
         unsigned long resolution;
         struct list_head *ack_list_head;
+        unsigned long flags;
+        bool use_work = false;
 
         if (timer == NULL)
@@ -836 +889 @@
         }
 
-        guard(spinlock_irqsave)(&timer->lock);
+        spin_lock_irqsave(&timer->lock, flags);
 
         /* remember the current resolution */
@@ -902 +955 @@
 
         /* do we have any slow callbacks? */
+        use_work = !list_empty(&timer->sack_list_head);
+        spin_unlock_irqrestore(&timer->lock, flags);
+
 #ifndef TARGET_OS2
-        if (!list_empty(&timer->sack_list_head))
+        if (use_work)
                 queue_work(system_highpri_wq, &timer->task_work);
 #endif
@@ -970 +1026 @@
                 return 0;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         if (! list_empty(&timer->open_list_head)) {
                 struct list_head *p, *n;
@@ -982 +1038 @@
         }
         list_del(&timer->device_list);
+        mutex_unlock(&register_mutex);
 
         if (timer->private_free)
@@ -1006 +1063 @@
                 return -EINVAL;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         list_for_each_entry(timer1, &snd_timer_list, device_list, struct snd_timer) {
                 if (timer1->tmr_class > timer->tmr_class)
@@ -1027 +1084 @@
                         continue;
                 /* conflicts.. */
+                mutex_unlock(&register_mutex);
                 return -EBUSY;
         }
         list_add_tail(&timer->device_list, &timer1->device_list);
+        mutex_unlock(&register_mutex);
         return 0;
 }
@@ -1038 +1097 @@
         struct snd_timer_instance *ti;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         list_del_init(&timer->device_list);
         /* wake up pending sleepers */
@@ -1045 +1104 @@
                         ti->disconnect(ti);
         }
+        mutex_unlock(&register_mutex);
         return 0;
 }
@@ -1050 +1110 @@
 void snd_timer_notify(struct snd_timer *timer, int event, struct timespec64 *tstamp)
 {
+        unsigned long flags;
         unsigned long resolution = 0;
         struct snd_timer_instance *ti, *ts;
@@ -1060 +1121 @@
                        event > SNDRV_TIMER_EVENT_MRESUME))
                 return;
-        guard(spinlock_irqsave)(&timer->lock);
+        spin_lock_irqsave(&timer->lock, flags);
         if (event == SNDRV_TIMER_EVENT_MSTART ||
             event == SNDRV_TIMER_EVENT_MCONTINUE ||
@@ -1072 +1133 @@
                                 ts->ccallback(ts, event, tstamp, resolution);
         }
+        spin_unlock_irqrestore(&timer->lock, flags);
 }
 EXPORT_SYMBOL(snd_timer_notify);
@@ -1233 +1295 @@
         unsigned long resolution;
 
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         list_for_each_entry(timer, &snd_timer_list, device_list, struct snd_timer) {
                 if (timer->card && timer->card->shutdown)
@@ -1255 +1317 @@
                 }
                 snd_iprintf(buffer, "%s :", timer->name);
-                scoped_guard(spinlock_irq, &timer->lock)
+                spin_lock_irq(&timer->lock);
                 resolution = snd_timer_hw_resolution(timer);
+                spin_unlock_irq(&timer->lock);
                 if (resolution)
                         snd_iprintf(buffer, " %lu.%03luus (%lu ticks)",
@@ -1272 +1335 @@
                                     ? "running" : "stopped");
         }
+        mutex_unlock(&register_mutex);
 }
 
@@ -1312 +1376 @@
         int prev;
 
-        guard(spinlock)(&tu->qlock);
+        spin_lock(&tu->qlock);
         if (tu->qused > 0) {
                 prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
@@ -1331 +1395 @@
         }
       __wake:
+        spin_unlock(&tu->qlock);
         snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
         wake_up(&tu->qchange_sleep);
@@ -1354 +1419 @@
         struct snd_timer_user *tu = timeri->callback_data;
         struct snd_timer_tread64 r1;
+        unsigned long flags;
 
         if (event >= SNDRV_TIMER_EVENT_START &&
@@ -1365 +1431 @@
         r1.tstamp_nsec = tstamp->tv_nsec;
         r1.val = resolution;
-        scoped_guard(spinlock_irqsave, &tu->qlock)
+        spin_lock_irqsave(&tu->qlock, flags);
         snd_timer_user_append_to_tqueue(tu, &r1);
+        spin_unlock_irqrestore(&tu->qlock, flags);
         snd_kill_fasync(tu->fasync, SIGIO, POLL_IN);
         wake_up(&tu->qchange_sleep);
@@ -1390 +1457 @@
         memset(&r1, 0, sizeof(r1));
         memset(&tstamp, 0, sizeof(tstamp));
-        scoped_guard(spinlock, &tu->qlock) {
+        spin_lock(&tu->qlock);
         if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) |
-                                   (1 << SNDRV_TIMER_EVENT_TICK))) == 0)
+                           (1 << SNDRV_TIMER_EVENT_TICK))) == 0) {
+                spin_unlock(&tu->qlock);
                 return;
+        }
         if (tu->last_resolution != resolution || ticks > 0) {
                 if (timer_tstamp_monotonic)
@@ -1406 +1475 @@
                 r1.tstamp_nsec = tstamp.tv_nsec;
                 r1.val = resolution;
-                snd_timer_user_append_to_tqueue(tu, &r1);
+                snd_timer_user_append_to_tqueue(tu, &r1);
                 tu->last_resolution = resolution;
-                append++;
-        }
+                append++;
+        }
         if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)
-                        break;
+                goto __wake;
         if (ticks == 0)
-                        break;
+                goto __wake;
         if (tu->qused > 0) {
                 prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
@@ -1422 +1491 @@
                         r->val += ticks;
                         append++;
-                                break;
+                        goto __wake;
                 }
         }
@@ -1431 +1500 @@
         snd_timer_user_append_to_tqueue(tu, &r1);
         append++;
-        }
+      __wake:
+        spin_unlock(&tu->qlock);
         if (append == 0)
                 return;
@@ -1453 +1523 @@
         }
 
-        guard(spinlock_irq)(&tu->qlock);
+        spin_lock_irq(&tu->qlock);
         kfree(tu->queue);
         kfree(tu->tqueue);
@@ -1460 +1530 @@
         tu->tqueue = tqueue;
         tu->qhead = tu->qtail = tu->qused = 0;
+        spin_unlock_irq(&tu->qlock);
 
         return 0;
@@ -1495 +1566 @@
                 tu = file->private_data;
                 file->private_data = NULL;
-                scoped_guard(mutex, &tu->ioctl_lock) {
+                mutex_lock(&tu->ioctl_lock);
                 if (tu->timeri) {
                         snd_timer_close(tu->timeri);
                         snd_timer_instance_free(tu->timeri);
                 }
-                }
+                mutex_unlock(&tu->ioctl_lock);
                 snd_fasync_free(tu->fasync);
                 kfree(tu->queue);
@@ -1535 +1606 @@
         if (copy_from_user(&id, _tid, sizeof(id)))
                 return -EFAULT;
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         if (id.dev_class < 0) {         /* first item */
                 if (list_empty(&snd_timer_list))
@@ -1612 +1683 @@
                 }
         }
+        mutex_unlock(&register_mutex);
         if (copy_to_user(_tid, &id, sizeof(*_tid)))
                 return -EFAULT;
@@ -1624 +1696 @@
         struct snd_timer *t;
         struct list_head *p;
+        int err = 0;
 
         ginfo = memdup_user(_ginfo, sizeof(*ginfo));
@@ -1632 +1705 @@
         memset(ginfo, 0, sizeof(*ginfo));
         ginfo->tid = tid;
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         t = snd_timer_find(&tid);
-        if (!t)
-                return -ENODEV;
+        if (t != NULL) {
                 ginfo->card = t->card ? t->card->number : -1;
                 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
@@ -1641 +1713 @@
                 strscpy(ginfo->id, t->id, sizeof(ginfo->id));
                 strscpy(ginfo->name, t->name, sizeof(ginfo->name));
-        scoped_guard(spinlock_irq, &t->lock)
+                spin_lock_irq(&t->lock);
                 ginfo->resolution = snd_timer_hw_resolution(t);
+                spin_unlock_irq(&t->lock);
                 if (t->hw.resolution_min > 0) {
                         ginfo->resolution_min = t->hw.resolution_min;
@@ -1650 +1723 @@
                         ginfo->clients++;
                 }
-        if (copy_to_user(_ginfo, ginfo, sizeof(*ginfo)))
-                return -EFAULT;
-        return 0;
+        } else {
+                err = -ENODEV;
+                }
+        mutex_unlock(&register_mutex);
+        if (err >= 0 && copy_to_user(_ginfo, ginfo, sizeof(*ginfo)))
+                err = -EFAULT;
+        kfree(ginfo);
+        return err;
 }
 
@@ -1658 +1736 @@
 {
         struct snd_timer *t;
-
-        guard(mutex)(&register_mutex);
+        int err;
+
+        mutex_lock(&register_mutex);
         t = snd_timer_find(&gparams->tid);
-        if (!t)
-                return -ENODEV;
-        if (!list_empty(&t->open_list_head))
-                return -EBUSY;
-        if (!t->hw.set_period)
-                return -ENOSYS;
-        return t->hw.set_period(t, gparams->period_num, gparams->period_den);
+        if (!t) {
+                err = -ENODEV;
+                goto _error;
+        }
+        if (!list_empty(&t->open_list_head)) {
+                err = -EBUSY;
+                goto _error;
+        }
+        if (!t->hw.set_period) {
+                err = -ENOSYS;
+                goto _error;
+        }
+        err = t->hw.set_period(t, gparams->period_num, gparams->period_den);
+_error:
+        mutex_unlock(&register_mutex);
+        return err;
 }
 
@@ -1693 +1781 @@
         memset(&gstatus, 0, sizeof(gstatus));
         gstatus.tid = tid;
-        guard(mutex)(&register_mutex);
+        mutex_lock(&register_mutex);
         t = snd_timer_find(&tid);
         if (t != NULL) {
-                guard(spinlock_irq)(&t->lock);
+                spin_lock_irq(&t->lock);
                 gstatus.resolution = snd_timer_hw_resolution(t);
                 if (t->hw.precise_resolution) {
@@ -1705 +1793 @@
                         gstatus.resolution_den = 1000000000uL;
                 }
+                spin_unlock_irq(&t->lock);
         } else {
                 err = -ENODEV;
         }
+        mutex_unlock(&register_mutex);
         if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus)))
                 err = -EFAULT;
@@ -1763 +1853 @@
         struct snd_timer_info *info __free(kfree) = NULL;
         struct snd_timer *t;
+        int err = 0;
 
         tu = file->private_data;
@@ -1779 +1870 @@
         strscpy(info->id, t->id, sizeof(info->id));
         strscpy(info->name, t->name, sizeof(info->name));
-        scoped_guard(spinlock_irq, &t->lock)
+        spin_lock_irq(&t->lock);
         info->resolution = snd_timer_hw_resolution(t);
+        spin_unlock_irq(&t->lock);
         if (copy_to_user(_info, info, sizeof(*_info)))
-                return -EFAULT;
-        return 0;
+                err = -EFAULT;
+        kfree(info);
+        return err;
 }
 
@@ -1841 +1934 @@
         }
         snd_timer_stop(tu->timeri);
-        scoped_guard(spinlock_irq, &t->lock) {
+        spin_lock_irq(&t->lock);
         tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO|
                                SNDRV_TIMER_IFLG_EXCLUSIVE|
@@ -1851 +1944 @@
         if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT)
                 tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT;
-        }
+        spin_unlock_irq(&t->lock);
         if (params.queue_size > 0 &&
             (unsigned int)tu->queue_size != params.queue_size) {
@@ -1858 +1951 @@
                         goto _end;
         }
-        scoped_guard(spinlock_irq, &tu->qlock) {
+        spin_lock_irq(&tu->qlock);
         tu->qhead = tu->qtail = tu->qused = 0;
         if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {
                 if (tu->tread) {
                         struct snd_timer_tread64 tread;
-
                         memset(&tread, 0, sizeof(tread));
                         tread.event = SNDRV_TIMER_EVENT_EARLY;
@@ -1872 +1964 @@
                 } else {
                         struct snd_timer_read *r = &tu->queue[0];
-
                         r->resolution = 0;
                         r->ticks = 0;
@@ -1881 +1972 @@
         tu->filter = params.filter;
         tu->ticks = params.ticks;
-        }
+        spin_unlock_irq(&tu->qlock);
         err = 0;
  _end:
@@ -1904 +1995 @@
         status.lost = tu->timeri->lost;
         status.overrun = tu->overrun;
-        scoped_guard(spinlock_irq, &tu->qlock)
+        spin_lock_irq(&tu->qlock);
         status.queue = tu->qused;
+        spin_unlock_irq(&tu->qlock);
         if (copy_to_user(_status, &status, sizeof(status)))
                 return -EFAULT;
@@ -1926 +2018 @@
         status.lost = tu->timeri->lost;
         status.overrun = tu->overrun;
-        scoped_guard(spinlock_irq, &tu->qlock)
+        spin_lock_irq(&tu->qlock);
         status.queue = tu->qused;
+        spin_unlock_irq(&tu->qlock);
         if (copy_to_user(_status, &status, sizeof(status)))
                 return -EFAULT;
@@ -2298 +2391 @@
 {
         struct snd_timer_user *tu = file->private_data;
-
-        guard(mutex)(&tu->ioctl_lock);
-        return __snd_timer_user_ioctl(file, cmd, arg, false);
+        long ret;
+
+        mutex_lock(&tu->ioctl_lock);
+        ret = __snd_timer_user_ioctl(file, cmd, arg, false);
+        mutex_unlock(&tu->ioctl_lock);
+        return ret;
 }
 
@@ -2435 +2531 @@
 
         mask = 0;
-        guard(spinlock_irq)(&tu->qlock);
+        spin_lock_irq(&tu->qlock);
         if (tu->qused)
                 mask |= EPOLLIN | EPOLLRDNORM;
         if (tu->disconnected)
                 mask |= EPOLLERR;
+        spin_unlock_irq(&tu->qlock);
 
         return mask;

GPL/branches/uniaud32-exp/alsa-kernel/hda/hdac_stream.c ¶

@@ -333 +333 @@
         snd_hdac_stream_updatel(azx_dev, SD_CTL, 0, SD_INT_MASK);
 
+#ifdef TARGET_OS2
+        azx_dev->fifo_size = snd_hdac_stream_readw(azx_dev, SD_FIFOSIZE) + 1;
+#else
         if (!code_loading) {
                 /* Once SDxFMT is set, the controller programs SDxFIFOS to non-zero value. */
@@ -342 +345 @@
                 azx_dev->fifo_size = reg;
         }
-
+#endif
         /* when LPIB delay correction gives a small negative value,
          * we ignore it; currently set the threshold statically to

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

@@ -82 +82 @@
         void *private_data;
         void (*private_free)(struct snd_kcontrol *kcontrol);
-        struct snd_kcontrol_volatile vd[] __counted_by(count);  /* volatile data */
+        struct snd_kcontrol_volatile vd[1] __counted_by(count); /* volatile data */
 };
 

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

@@ -19 +19 @@
 #include <sound/memalloc.h>
 #include <sound/hda_verbs.h>
+#ifndef TARGET_OS2
 #include <drm/intel/i915_component.h>
+#endif
 
 /* codec node id */

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

@@ -684 +684 @@
         } while (0)
 
+#ifndef TARGET_OS2
 /* definitions for guard(); use like guard(pcm_stream_lock) */
 DEFINE_LOCK_GUARD_1(pcm_stream_lock, struct snd_pcm_substream,
@@ -695 +696 @@
                     snd_pcm_stream_unlock_irqrestore(_T->lock, _T->flags),
                     unsigned long flags)
+#endif
 
 /**

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

@@ -363 +363 @@
         unsigned short id16[8];
         unsigned int id32[4];
-} __attribute__((deprecated));
+} /*__attribute__((deprecated))*/;
 
 struct snd_pcm_info {

GPL/branches/uniaud32-exp/alsa-kernel/pci/ac97/ac97_codec.c ¶

@@ -3028 +3028 @@
                 result = apply_quirk_str(ac97, override);
                 if (result < 0)
-                        snd_printk(KERN_ERR "applying quirk type %s failed (%d)\n", override, result);
+                        ac97_err(ac97, "applying quirk type %s failed (%d)\n",
+                                 override, result);
                 return result;
         }
@@ -3042 +3043 @@
                         if (quirk->codec_id && quirk->codec_id != ac97->id)
                                 continue;
-                        snd_printdd("ac97 quirk for %s (%04x:%04x)\n", quirk->name, ac97->subsystem_vendor, ac97->subsystem_device);
+                        ac97_dbg(ac97, "ac97 quirk for %s (%04x:%04x)\n",
+                                 quirk->name, ac97->subsystem_vendor,
+                                 ac97->subsystem_device);
                         result = apply_quirk(ac97, quirk->type);
                         if (result < 0)
-                                snd_printk(KERN_ERR "applying quirk type %d for %s failed (%d)\n", quirk->type, quirk->name, result);
+                                ac97_err(ac97,
+                                         "applying quirk type %d for %s failed (%d)\n",
+                                         quirk->type, quirk->name, result);
                         return result;
                 }

GPL/branches/uniaud32-exp/alsa-kernel/pci/hda/Makefile ¶

@@ -12 +12 @@
 #
 #===================================================================
-FILES = hda_intel.obj hda_codec.obj hda_controller.obj hda_auto_parser.obj hda_jack.obj &
-  hda_proc.obj hda_generic.obj hda_hwdep.obj hda_sysfs.obj hda_bind.obj hda_eld.obj &
-  patch_analog.obj patch_cmedia.obj patch_conexant.obj patch_ca0110.obj patch_ca0132.obj patch_cirrus.obj &
-  patch_hdmi.obj patch_realtek.obj patch_si3054.obj patch_sigmatel.obj patch_via.obj
+FILES = hda_intel.obj hda_codec.obj hda_controller.obj hda_auto_parser.obj &
+  hda_jack.obj hda_proc.obj hda_generic.obj hda_hwdep.obj hda_sysfs.obj  &
+  hda_bind.obj hda_eld.obj hda_component.obj patch_analog.obj &
+  patch_cmedia.obj patch_conexant.obj patch_ca0110.obj patch_ca0132.obj &
+  patch_cirrus.obj patch_hdmi.obj patch_realtek.obj patch_si3054.obj &
+  patch_sigmatel.obj patch_via.obj
 
 TARGET = hda

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

@@ -7 +7 @@
  */
 
+#ifndef __HDA_COMPONENT_H__
+#define __HDA_COMPONENT_H__
+
+#include <linux/acpi.h>
 #include <linux/component.h>
+#include <linux/mutex.h>
+#include <sound/hda_codec.h>
 
 #define HDA_MAX_COMPONENTS      4
@@ -15 +21 @@
         struct device *dev;
         char name[HDA_MAX_NAME_SIZE];
-        struct hda_codec *codec;
+        struct acpi_device *adev;
+        bool acpi_notifications_supported;
+//      void (*acpi_notify)(acpi_handle handle, u32 event, struct device *dev);
         void (*pre_playback_hook)(struct device *dev, int action);
         void (*playback_hook)(struct device *dev, int action);
         void (*post_playback_hook)(struct device *dev, int action);
 };
+
+struct hda_component_parent {
+        struct mutex mutex;
+        struct hda_codec *codec;
+        struct hda_component comps[HDA_MAX_COMPONENTS];
+};
+
+#ifdef CONFIG_ACPI
+void hda_component_acpi_device_notify(struct hda_component_parent *parent,
+                                      acpi_handle handle, u32 event, void *data);
+int hda_component_manager_bind_acpi_notifications(struct hda_codec *cdc,
+                                                  struct hda_component_parent *parent,
+                                                  acpi_notify_handler handler, void *data);
+void hda_component_manager_unbind_acpi_notifications(struct hda_codec *cdc,
+                                                     struct hda_component_parent *parent,
+                                                     acpi_notify_handler handler);
+#else
+static inline void hda_component_acpi_device_notify(struct hda_component_parent *parent,
+                                                    acpi_handle handle,
+                                                    u32 event,
+                                                    void *data)
+{
+}
+
+static inline int hda_component_manager_bind_acpi_notifications(struct hda_codec *cdc,
+                                                                struct hda_component_parent *parent,
+                                                                acpi_notify_handler handler,
+                                                                void *data)
+
+{
+        return 0;
+}
+
+static inline void hda_component_manager_unbind_acpi_notifications(struct hda_codec *cdc,
+                                                                   struct hda_component_parent *parent,
+                                                                   acpi_notify_handler handler)
+{
+}
+#endif /* ifdef CONFIG_ACPI */
+
+void hda_component_manager_playback_hook(struct hda_component_parent *parent, int action);
+
+int hda_component_manager_init(struct hda_codec *cdc,
+                               struct hda_component_parent *parent, int count,
+                               const char *bus, const char *hid,
+                               const char *match_str,
+                               const struct component_master_ops *ops);
+
+void hda_component_manager_free(struct hda_component_parent *parent,
+                                const struct component_master_ops *ops);
+
+int hda_component_manager_bind(struct hda_codec *cdc, struct hda_component_parent *parent);
+
+static inline struct hda_component *hda_component_from_index(struct hda_component_parent *parent,
+                                                             int index)
+{
+        if (!parent)
+                return NULL;
+
+        if (index < 0 || index >= ARRAY_SIZE(parent->comps))
+                return NULL;
+
+        return &parent->comps[index];
+}
+
+static inline void hda_component_manager_unbind(struct hda_codec *cdc,
+                                                struct hda_component_parent *parent)
+{
+        mutex_lock(&parent->mutex);
+        component_unbind_all(hda_codec_dev(cdc), parent);
+        mutex_unlock(&parent->mutex);
+}
+
+#endif /* ifndef __HDA_COMPONENT_H__ */

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

@@ -67 +67 @@
         {0x43, CM9825_VERB_SET_CDALR, 0xf6},    /* Class D */
         {0x43, CM9825_VERB_SET_OTP, 0xcd},      /* OTP set */
-        {}
+        {0}
 };
 
@@ -95 +95 @@
         {0x43, CM9825_VERB_SET_HPF_1, 0x40},    /* HPF set */
         {0x43, CM9825_VERB_SET_HPF_2, 0x40},    /* HPF set */
-        {}
+        {0}
 };
 
@@ -106 +106 @@
         {0x43, CM9825_VERB_SET_DACTRL, 0x00},   /* DACTRL set */
         {0x43, CM9825_VERB_SET_VDO, 0xc4},      /* VDO set */
-        {}
+        {0}
 };
 
@@ -117 +117 @@
         {0x43, CM9825_VERB_SET_VDO, 0x80},      /* VDO set */
         {0x42, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},   /* PIN on */
-        {}
+        {0}
 };
 

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

@@ -19 +19 @@
 #include <linux/dmi.h>
 #include <linux/module.h>
-#include <linux/i2c.h>
+//#include <linux/i2c.h>
 #include <linux/input.h>
 #include <linux/leds.h>
 #include <linux/ctype.h>
-#include <linux/spi/spi.h>
+//#include <linux/spi/spi.h>
 #include <sound/core.h>
 #include <sound/jack.h>
@@ -3110 +3110 @@
                         { 0x18, PIN_VREF50 }, /* rear mic */
                         { 0x19, PIN_VREF50 }, /* front mic */
-                        {}
+                        {0}
                 }
         },
@@ -3535 +3535 @@
                 .v.pins = (const struct hda_pintbl[]) {
                         { 0x18, PIN_VREF100 }, /* headset mic */
-                        {}
+                        {0}
                 }
         },
@@ -5698 +5698 @@
 }
 
+#ifdef NOT_USED
 static void gpio2_mic_hotkey_event(struct hda_codec *codec,
                                    struct hda_jack_callback *event)
@@ -5744 +5745 @@
         return 0;
 }
+#endif
 
 /* GPIO1 = set according to SKU external amp
@@ -7810 +7812 @@
         int i, count = 0, count_devindex = 0;
 
+#ifndef TARGET_OS2
         for (i = 0; i < ARRAY_SIZE(acpi_ids); ++i) {
                 adev = acpi_dev_get_first_match_dev(acpi_ids[i].hid, NULL, -1);
@@ -7815 +7818 @@
                 break;
         }
+
         if (!adev) {
                 codec_dbg(cdc, "Did not find ACPI entry for a Cirrus Amp\n");
@@ -7851 +7855 @@
         if (count_devindex > 0)
                 count = count_devindex;
-
+#endif
         match = devm_kasprintf(dev, GFP_KERNEL, "-%%s:00-%s.%%d", acpi_ids[i].name);
         if (!match)
@@ -7885 +7889 @@
 }
 
+#ifdef NOT_USED
 static void alc287_fixup_legion_16ithg6_speakers(struct hda_codec *cdc, const struct hda_fixup *fix,
                                                  int action)
@@ -7890 +7895 @@
         comp_generic_fixup(cdc, action, "i2c", "CLSA0101", "-%s:00-cs35l41-hda.%d", 2);
 }
+#endif
 
 static void alc285_fixup_asus_ga403u(struct hda_codec *cdc, const struct hda_fixup *fix, int action)
@@ -8157 +8163 @@
                 { 0x14, 0x90170110 }, // top/treble
                 { 0x17, 0x90170111 }, // bottom/bass
-                { }
+                {0}
         };
 
@@ -8173 +8179 @@
 
         cs35l41_fixup_i2c_two(codec, fix, action);
+#ifdef NOT_USED
         alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
         alc245_fixup_hp_gpio_led(codec, fix, action);
+#endif
 }
 
@@ -8191 +8199 @@
                 { 0x14, 0x90170110 }, // top/treble
                 { 0x17, 0x90170111 }, // bottom/bass
-                { }
+                {0}
         };
 
@@ -8216 +8224 @@
 
         cs35l41_fixup_i2c_two(codec, fix, action);
+#ifdef NOT_USED
         alc245_fixup_hp_mute_led_coefbit(codec, fix, action);
         alc245_fixup_hp_gpio_led(codec, fix, action);
+#endif
 }
 
@@ -8240 +8250 @@
 static void alc287_s4_power_gpio3_default(struct hda_codec *codec)
 {
+#ifndef TARGET_OS2
         if (is_s4_suspend(codec)) {
                 alc_write_coefex_idx(codec, 0x5a, 0x00, 0x554f); /* write gpio3 as default value */
         }
+#endif
 }
 
@@ -10642 +10654 @@
                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x6b },
                         { 0x20, AC_VERB_SET_PROC_COEF, 0x5060 },
-                        {}
+                        {0}
                 },
                 .chained = true,
@@ -10721 +10733 @@
                         { 0x1e, 0x411111f0 },
                         { 0x21, 0x03211020 },
-                        {}
+                        {0}
                 },
                 .chained = true,
@@ -10818 +10830 @@
                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
-                         {}
+                         {0}
                 },
                 .chained = true,
@@ -10865 +10877 @@
                          { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
                          { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
-                         {}
+                         {0}
                 },
                 .chained = true,
@@ -10891 +10903 @@
                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0 },
                         { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 },
-                        {}
+                        {0}
                 },
                 .chained = true,
@@ -11157 +11169 @@
                 .v.func = alc285_fixup_asus_ga403u,
         },
+#ifdef NOT_USED
         [ALC285_FIXUP_ASUS_GA403U_HEADSET_MIC] = {
                 .type = HDA_FIXUP_PINS,
@@ -11167 +11180 @@
                 .chain_id = ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1
         },
+#endif
         [ALC285_FIXUP_ASUS_GU605_SPI_SPEAKER2_TO_DAC1] = {
                 .type = HDA_FIXUP_FUNC,
@@ -11173 +11187 @@
                 .chain_id = ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC,
         },
+#ifdef NOT_USED
         [ALC285_FIXUP_ASUS_GU605_SPI_2_HEADSET_MIC] = {
                 .type = HDA_FIXUP_PINS,
@@ -11181 +11196 @@
                 },
         },
+#endif
         [ALC285_FIXUP_ASUS_GA403U_I2C_SPEAKER2_TO_DAC1] = {
                 .type = HDA_FIXUP_FUNC,
@@ -11205 +11221 @@
                 .chain_id = ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
         },
+#ifdef NOT_USED
         [ALC269_FIXUP_VAIO_VJFH52_MIC_NO_PRESENCE] = {
                 .type = HDA_FIXUP_PINS,
@@ -11222 +11239 @@
                 },
         },
+#endif
 };
 
@@ -14197 +14215 @@
                         { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 },
                         { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 },
-                        {}
+                        {0}
                 },
         },
@@ -14219 +14237 @@
                 .v.pins = (const struct hda_pintbl[]) {
                         { 0x19, 0x01a1913c }, /* use as headset mic, without its own jack detect */
-                        { }
+                        {0}
                 },
         },
@@ -14241 +14259 @@
                 .v.verbs = (const struct hda_verb[]) {
                         { 0x14, AC_VERB_SET_EAPD_BTLENABLE, 0 },
-                        {}
+                        {0}
                 },
         },

GPL/branches/uniaud32-exp/alsa-kernel/pci/maestro3.c ¶

@@ -2590 +2590 @@
         card->sync_irq = chip->irq;
 
+#ifndef TARGET_OS2
         if (IS_ENABLED(CONFIG_PM_SLEEP)) {
         chip->suspend_mem =
@@ -2598 +2599 @@
                 dev_warn(card->dev, "can't allocate apm buffer\n");
         }
-
+#endif
         err = snd_m3_mixer(chip);
         if (err < 0)

GPL/branches/uniaud32-exp/include/linux/compiler.h ¶

@@ -16 +16 @@
 
 #define __GNUC__  3
+
+#define __counted_by(member)
+#define __free(x)
+
+/* Indirect macros required for expanded argument pasting, eg. __LINE__. */
+#define ___PASTE(a,b) a##b
+#define __PASTE(a,b) ___PASTE(a,b)
+
+#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
 
 #ifndef __ASSEMBLY__

GPL/branches/uniaud32-exp/include/linux/device.h ¶

@@ -58 +58 @@
   struct device   * parent;
   struct device_private *p;
-  struct bus_type * bus;    /* type of bus device is on */
+  const struct bus_type * bus;    /* type of bus device is on */
   struct kobject kobj;
   const char            *init_name; /* initial name of the device */

GPL/branches/uniaud32-exp/include/linux/export.h ¶

@@ -6 +6 @@
 #define EXPORT_SYMBOL(a)
 #define EXPORT_SYMBOL_GPL(a)
+#define EXPORT_SYMBOL_NS_GPL(a)
 
 #endif /* _LINUX_EXPORT_H */

GPL/branches/uniaud32-exp/include/linux/kernel.h ¶

@@ -128 +128 @@
 
 _WCRTLINK extern int    sscanf( const char *__s, const char *__format, ... );
-
+typedef void *acpi_handle;      /* Actually a ptr to a NS Node */
+typedef
+void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context);
 #endif

GPL/branches/uniaud32-exp/include/linux/module.h ¶

@@ -116 +116 @@
         char name[MODULE_NAME_LEN];
 };
+#define MODULE_IMPORT_NS(x)
 #endif /* _LINUX_MODULE_H */

GPL/branches/uniaud32-exp/include/linux/pci_ids.h ¶

@@ -584 +584 @@
 #define PCI_DEVICE_ID_AMD_1AH_M70H_DF_F3 0x12bb
 #define PCI_DEVICE_ID_AMD_MI200_DF_F3   0x14d3
+#define PCI_DEVICE_ID_AMD_MI300_DF_F3   0x152b
 #define PCI_DEVICE_ID_AMD_VANGOGH_USB   0x163a
 #define PCI_DEVICE_ID_AMD_CNB17H_F3     0x1703
@@ -2589 +2590 @@
 #define PCI_VENDOR_ID_REDHAT            0x1b36
 
+#define PCI_VENDOR_ID_WCHIC             0x1c00
+#define PCI_DEVICE_ID_WCHIC_CH382_0S1P  0x3050
+#define PCI_DEVICE_ID_WCHIC_CH382_2S1P  0x3250
+#define PCI_DEVICE_ID_WCHIC_CH382_2S    0x3253
+
 #define PCI_VENDOR_ID_SILICOM_DENMARK   0x1c2c
 
@@ -2602 +2608 @@
 #define PCI_VENDOR_ID_HYGON             0x1d94
 
+#define PCI_VENDOR_ID_META              0x1d9b
+
 #define PCI_VENDOR_ID_FUNGIBLE          0x1dad
 
@@ -2608 +2616 @@
 #define PCI_VENDOR_ID_TEKRAM            0x1de1
 #define PCI_DEVICE_ID_TEKRAM_DC290      0xdc29
+
+#define PCI_VENDOR_ID_ALIBABA           0x1ded
+
+#define PCI_VENDOR_ID_CXL               0x1e98
 
 #define PCI_VENDOR_ID_TEHUTI            0x1fc9
@@ -2636 +2648 @@
 #define PCI_VENDOR_ID_AKS               0x416c
 #define PCI_DEVICE_ID_AKS_ALADDINCARD   0x0100
+
+#define PCI_VENDOR_ID_WCHCN             0x4348
+#define PCI_DEVICE_ID_WCHCN_CH353_4S    0x3453
+#define PCI_DEVICE_ID_WCHCN_CH353_2S1PF 0x5046
+#define PCI_DEVICE_ID_WCHCN_CH353_1S1P  0x5053
+#define PCI_DEVICE_ID_WCHCN_CH353_2S1P  0x7053
 
 #define PCI_VENDOR_ID_ACCESSIO          0x494f
@@ -2703 +2721 @@
 #define PCI_DEVICE_ID_INTEL_82815_CGC   0x1132
 #define PCI_DEVICE_ID_INTEL_SST_TNG     0x119a
+#define PCI_DEVICE_ID_INTEL_DSA_GNRD    0x11fb
+#define PCI_DEVICE_ID_INTEL_DSA_DMR     0x1212
+#define PCI_DEVICE_ID_INTEL_IAA_DMR     0x1216
 #define PCI_DEVICE_ID_INTEL_82092AA_0   0x1221
 #define PCI_DEVICE_ID_INTEL_82437       0x122d
@@ -3112 +3133 @@
 #define PCI_DEVICE_ID_INTEL_HDA_LNL_P   0xa828
 #define PCI_DEVICE_ID_INTEL_S21152BB    0xb152
+#define PCI_DEVICE_ID_INTEL_HDA_BMG     0xe2f7
+#define PCI_DEVICE_ID_INTEL_HDA_PTL_H   0xe328
+#define PCI_DEVICE_ID_INTEL_HDA_PTL     0xe428
 #define PCI_DEVICE_ID_INTEL_HDA_CML_R   0xf0c8
 #define PCI_DEVICE_ID_INTEL_HDA_RKL_S   0xf1c8

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

@@ -291 +291 @@
         .restore = resume_fn,
 
+#define SYSTEM_SLEEP_PM_OPS SET_SYSTEM_SLEEP_PM_OPS
 /*
  * Use this if you want to use the same suspend and resume callbacks for suspend
@@ -349 +350 @@
 #define PMSG_RESTORE    0
 #define pm_sleep_ptr(_ptr) _ptr
+
+#define pm_ptr(_ptr) _ptr
+
 #endif /* _LINUX_PM_H */

GPL/branches/uniaud32-exp/lib32/Makefile ¶

@@ -31 +31 @@
   instropl2.obj instropl3.obj vsprintf.obj bitmap.obj find_next_bit.obj &
   regmap.obj regcache.obj regcache-flat.obj regcache-rbtree.obj &
-  regcache-maple.obj component.obj
+  component.obj
 
 TARGET = linuxlib

GPL/branches/uniaud32-exp/lib32/regcache.c ¶

@@ -24 +24 @@
 static const struct regcache_ops *cache_types[] = {
         &regcache_rbtree_ops,
+#if 0 // not (yet?) supported on OS/2
         &regcache_maple_ops,
+#endif
         &regcache_flat_ops,
 };

GPL/branches/uniaud32-exp/lib32/regmap.c ¶

@@ -20 +20 @@
 #include <linux/log2.h>
 //#include <linux/hwspinlock.h>
-#include <asm/unaligned.h>
+#include <linux/unaligned.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>

GPL/branches/uniaud32-exp/uniaud.inc ¶

@@ -13 +13 @@
 # ex RC3  GA  FIXPACK2 beta_47
 # Comment out to avoid a fixpack line in bldlevel
-FIXPACK = SVN
+FIXPACK = SVN r764