Merge branch 'topic/cleanup' into for-next

diff --git a/sound/core/sound.c b/sound/core/sound.c
index 185cec01ee258cceea232209c24b8aa5478b300b..5fc93d00572a5fc4f9ecfa3ba070aa2b3b8efb6f 100644 (file)
--- a/sound/core/sound.c
+++ b/sound/core/sound.c
@@ -186,7 +186,7 @@ static const struct file_operations snd_fops =
 };
 
 #ifdef CONFIG_SND_DYNAMIC_MINORS
-static int snd_find_free_minor(int type)
+static int snd_find_free_minor(int type, struct snd_card *card, int dev)
 {
        int minor;
 
@@ -209,7 +209,7 @@ static int snd_find_free_minor(int type)
        return -EBUSY;
 }
 #else
-static int snd_kernel_minor(int type, struct snd_card *card, int dev)
+static int snd_find_free_minor(int type, struct snd_card *card, int dev)
 {
        int minor;
 
@@ -237,6 +237,8 @@ static int snd_kernel_minor(int type, struct snd_card *card, int dev)
        }
        if (snd_BUG_ON(minor < 0 || minor >= SNDRV_OS_MINORS))
                return -EINVAL;
+       if (snd_minors[minor])
+               return -EBUSY;
        return minor;
 }
 #endif
@@ -276,13 +278,7 @@ int snd_register_device(int type, struct snd_card *card, int dev,
        preg->private_data = private_data;
        preg->card_ptr = card;
        mutex_lock(&sound_mutex);
-#ifdef CONFIG_SND_DYNAMIC_MINORS
-       minor = snd_find_free_minor(type);
-#else
-       minor = snd_kernel_minor(type, card, dev);
-       if (minor >= 0 && snd_minors[minor])
-               minor = -EBUSY;
-#endif
+       minor = snd_find_free_minor(type, card, dev);
        if (minor < 0) {
                err = minor;
                goto error;

diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index ca67f896d11757bc05be43804d367175b282dad0..cb666c73712d15276b411cdce11c7994380d4ffb 100644 (file)
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -6043,23 +6043,30 @@ hdspm_hw_constraints_aes32_sample_rates = {
        .mask = 0
 };
 
-static int snd_hdspm_playback_open(struct snd_pcm_substream *substream)
+static int snd_hdspm_open(struct snd_pcm_substream *substream)
 {
        struct hdspm *hdspm = snd_pcm_substream_chip(substream);
        struct snd_pcm_runtime *runtime = substream->runtime;
+       bool playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
 
        spin_lock_irq(&hdspm->lock);
-
        snd_pcm_set_sync(substream);
+       runtime->hw = (playback) ? snd_hdspm_playback_subinfo :
+               snd_hdspm_capture_subinfo;
 
+       if (playback) {
+               if (hdspm->capture_substream == NULL)
+                       hdspm_stop_audio(hdspm);
 
-       runtime->hw = snd_hdspm_playback_subinfo;
-
-       if (hdspm->capture_substream == NULL)
-               hdspm_stop_audio(hdspm);
+               hdspm->playback_pid = current->pid;
+               hdspm->playback_substream = substream;
+       } else {
+               if (hdspm->playback_substream == NULL)
+                       hdspm_stop_audio(hdspm);
 
-       hdspm->playback_pid = current->pid;
-       hdspm->playback_substream = substream;
+               hdspm->capture_pid = current->pid;
+               hdspm->capture_substream = substream;
+       }
 
        spin_unlock_irq(&hdspm->lock);
 
@@ -6094,108 +6101,42 @@ static int snd_hdspm_playback_open(struct snd_pcm_substream *substream)
                                &hdspm_hw_constraints_aes32_sample_rates);
        } else {
                snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                               snd_hdspm_hw_rule_rate_out_channels, hdspm,
+                               (playback ?
+                                snd_hdspm_hw_rule_rate_out_channels :
+                                snd_hdspm_hw_rule_rate_in_channels), hdspm,
                                SNDRV_PCM_HW_PARAM_CHANNELS, -1);
        }
 
        snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                       snd_hdspm_hw_rule_out_channels, hdspm,
+                       (playback ? snd_hdspm_hw_rule_out_channels :
+                        snd_hdspm_hw_rule_in_channels), hdspm,
                        SNDRV_PCM_HW_PARAM_CHANNELS, -1);
 
        snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                       snd_hdspm_hw_rule_out_channels_rate, hdspm,
+                       (playback ? snd_hdspm_hw_rule_out_channels_rate :
+                        snd_hdspm_hw_rule_in_channels_rate), hdspm,
                        SNDRV_PCM_HW_PARAM_RATE, -1);
 
        return 0;
 }
 
-static int snd_hdspm_playback_release(struct snd_pcm_substream *substream)
+static int snd_hdspm_release(struct snd_pcm_substream *substream)
 {
        struct hdspm *hdspm = snd_pcm_substream_chip(substream);
+       bool playback = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK);
 
        spin_lock_irq(&hdspm->lock);
 
-       hdspm->playback_pid = -1;
-       hdspm->playback_substream = NULL;
-
-       spin_unlock_irq(&hdspm->lock);
-
-       return 0;
-}
-
-
-static int snd_hdspm_capture_open(struct snd_pcm_substream *substream)
-{
-       struct hdspm *hdspm = snd_pcm_substream_chip(substream);
-       struct snd_pcm_runtime *runtime = substream->runtime;
-
-       spin_lock_irq(&hdspm->lock);
-       snd_pcm_set_sync(substream);
-       runtime->hw = snd_hdspm_capture_subinfo;
-
-       if (hdspm->playback_substream == NULL)
-               hdspm_stop_audio(hdspm);
-
-       hdspm->capture_pid = current->pid;
-       hdspm->capture_substream = substream;
-
-       spin_unlock_irq(&hdspm->lock);
-
-       snd_pcm_hw_constraint_msbits(runtime, 0, 32, 24);
-       snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE);
-
-       switch (hdspm->io_type) {
-       case AIO:
-       case RayDAT:
-               snd_pcm_hw_constraint_minmax(runtime,
-                                            SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
-                                            32, 4096);
-               snd_pcm_hw_constraint_minmax(runtime,
-                                            SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
-                                            16384, 16384);
-               break;
-
-       default:
-               snd_pcm_hw_constraint_minmax(runtime,
-                                            SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
-                                            64, 8192);
-               snd_pcm_hw_constraint_minmax(runtime,
-                                            SNDRV_PCM_HW_PARAM_PERIODS,
-                                            2, 2);
-               break;
-       }
-
-       if (AES32 == hdspm->io_type) {
-               runtime->hw.rates |= SNDRV_PCM_RATE_KNOT;
-               snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                               &hdspm_hw_constraints_aes32_sample_rates);
+       if (playback) {
+               hdspm->playback_pid = -1;
+               hdspm->playback_substream = NULL;
        } else {
-               snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
-                               snd_hdspm_hw_rule_rate_in_channels, hdspm,
-                               SNDRV_PCM_HW_PARAM_CHANNELS, -1);
+               hdspm->capture_pid = -1;
+               hdspm->capture_substream = NULL;
        }
 
-       snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                       snd_hdspm_hw_rule_in_channels, hdspm,
-                       SNDRV_PCM_HW_PARAM_CHANNELS, -1);
-
-       snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
-                       snd_hdspm_hw_rule_in_channels_rate, hdspm,
-                       SNDRV_PCM_HW_PARAM_RATE, -1);
-
-       return 0;
-}
-
-static int snd_hdspm_capture_release(struct snd_pcm_substream *substream)
-{
-       struct hdspm *hdspm = snd_pcm_substream_chip(substream);
-
-       spin_lock_irq(&hdspm->lock);
-
-       hdspm->capture_pid = -1;
-       hdspm->capture_substream = NULL;
-
        spin_unlock_irq(&hdspm->lock);
+
        return 0;
 }
 
@@ -6413,21 +6354,9 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
        return 0;
 }
 
-static struct snd_pcm_ops snd_hdspm_playback_ops = {
-       .open = snd_hdspm_playback_open,
-       .close = snd_hdspm_playback_release,
-       .ioctl = snd_hdspm_ioctl,
-       .hw_params = snd_hdspm_hw_params,
-       .hw_free = snd_hdspm_hw_free,
-       .prepare = snd_hdspm_prepare,
-       .trigger = snd_hdspm_trigger,
-       .pointer = snd_hdspm_hw_pointer,
-       .page = snd_pcm_sgbuf_ops_page,
-};
-
-static struct snd_pcm_ops snd_hdspm_capture_ops = {
-       .open = snd_hdspm_capture_open,
-       .close = snd_hdspm_capture_release,
+static struct snd_pcm_ops snd_hdspm_ops = {
+       .open = snd_hdspm_open,
+       .close = snd_hdspm_release,
        .ioctl = snd_hdspm_ioctl,
        .hw_params = snd_hdspm_hw_params,
        .hw_free = snd_hdspm_hw_free,
@@ -6521,9 +6450,9 @@ static int snd_hdspm_create_pcm(struct snd_card *card,
        strcpy(pcm->name, hdspm->card_name);
 
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
-                       &snd_hdspm_playback_ops);
+                       &snd_hdspm_ops);
        snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
-                       &snd_hdspm_capture_ops);
+                       &snd_hdspm_ops);
 
        pcm->info_flags = SNDRV_PCM_INFO_JOINT_DUPLEX;