1 files changed, 83 insertions, 70 deletions

diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 493e3946756f..6e2f7ef7ddb1 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -1241,10 +1241,30 @@ static int hdspm_external_sample_rate(struct hdspm *hdspm)
         return rate;
 }
 
+/* return latency in samples per period */
+static int hdspm_get_latency(struct hdspm *hdspm)
+{
+        int n;
+
+        n = hdspm_decode_latency(hdspm->control_register);
+
+        /* Special case for new RME cards with 32 samples period size.
+         * The three latency bits in the control register
+         * (HDSP_LatencyMask) encode latency values of 64 samples as
+         * 0, 128 samples as 1 ... 4096 samples as 6. For old cards, 7
+         * denotes 8192 samples, but on new cards like RayDAT or AIO,
+         * it corresponds to 32 samples.
+         */
+        if ((7 == n) && (RayDAT == hdspm->io_type || AIO == hdspm->io_type))
+                n = -1;
+
+        return 1 << (n + 6);
+}
+
 /* Latency function */
 static inline void hdspm_compute_period_size(struct hdspm *hdspm)
 {
-        hdspm->period_bytes = 1 << ((hdspm_decode_latency(hdspm->control_register) + 8));
+        hdspm->period_bytes = 4 * hdspm_get_latency(hdspm);
 }
 
 
@@ -1303,12 +1323,27 @@ static int hdspm_set_interrupt_interval(struct hdspm *s, unsigned int frames)
 
         spin_lock_irq(&s->lock);
 
-        frames >>= 7;
-        n = 0;
-        while (frames) {
-                n++;
-                frames >>= 1;
+        if (32 == frames) {
+                /* Special case for new RME cards like RayDAT/AIO which
+                 * support period sizes of 32 samples. Since latency is
+                 * encoded in the three bits of HDSP_LatencyMask, we can only
+                 * have values from 0 .. 7. While 0 still means 64 samples and
+                 * 6 represents 4096 samples on all cards, 7 represents 8192
+                 * on older cards and 32 samples on new cards.
+                 *
+                 * In other words, period size in samples is calculated by
+                 * 2^(n+6) with n ranging from 0 .. 7.
+                 */
+                n = 7;
+        } else {
+                frames >>= 7;
+                n = 0;
+                while (frames) {
+                        n++;
+                        frames >>= 1;
+                }
         }
+
         s->control_register &= ~HDSPM_LatencyMask;
         s->control_register |= hdspm_encode_latency(n);
 
@@ -4801,8 +4836,7 @@ snd_hdspm_proc_read_madi(struct snd_info_entry * entry,
 
         snd_iprintf(buffer, "--- Settings ---\n");
 
-        x = 1 << (6 + hdspm_decode_latency(hdspm->control_register &
-                                                        HDSPM_LatencyMask));
+        x = hdspm_get_latency(hdspm);
 
         snd_iprintf(buffer,
                 "Size (Latency): %d samples (2 periods of %lu bytes)\n",
@@ -4965,8 +4999,7 @@ snd_hdspm_proc_read_aes32(struct snd_info_entry * entry,
 
         snd_iprintf(buffer, "--- Settings ---\n");
 
-        x = 1 << (6 + hdspm_decode_latency(hdspm->control_register &
-                                HDSPM_LatencyMask));
+        x = hdspm_get_latency(hdspm);
 
         snd_iprintf(buffer,
                     "Size (Latency): %d samples (2 periods of %lu bytes)\n",
@@ -5672,19 +5705,6 @@ static int snd_hdspm_prepare(struct snd_pcm_substream *substream)
         return 0;
 }
 
-static unsigned int period_sizes_old[] = {
-        64, 128, 256, 512, 1024, 2048, 4096
-};
-
-static unsigned int period_sizes_new[] = {
-        32, 64, 128, 256, 512, 1024, 2048, 4096
-};
-
-/* RayDAT and AIO always have a buffer of 16384 samples per channel */
-static unsigned int raydat_aio_buffer_sizes[] = {
-        16384
-};
-
 static struct snd_pcm_hardware snd_hdspm_playback_subinfo = {
         .info = (SNDRV_PCM_INFO_MMAP |
                  SNDRV_PCM_INFO_MMAP_VALID |
@@ -5703,8 +5723,8 @@ static struct snd_pcm_hardware snd_hdspm_playback_subinfo = {
         .channels_max = HDSPM_MAX_CHANNELS,
         .buffer_bytes_max =
             HDSPM_CHANNEL_BUFFER_BYTES * HDSPM_MAX_CHANNELS,
-        .period_bytes_min = (64 * 4),
-        .period_bytes_max = (4096 * 4) * HDSPM_MAX_CHANNELS,
+        .period_bytes_min = (32 * 4),
+        .period_bytes_max = (8192 * 4) * HDSPM_MAX_CHANNELS,
         .periods_min = 2,
         .periods_max = 512,
         .fifo_size = 0
@@ -5728,31 +5748,13 @@ static struct snd_pcm_hardware snd_hdspm_capture_subinfo = {
         .channels_max = HDSPM_MAX_CHANNELS,
         .buffer_bytes_max =
             HDSPM_CHANNEL_BUFFER_BYTES * HDSPM_MAX_CHANNELS,
-        .period_bytes_min = (64 * 4),
-        .period_bytes_max = (4096 * 4) * HDSPM_MAX_CHANNELS,
+        .period_bytes_min = (32 * 4),
+        .period_bytes_max = (8192 * 4) * HDSPM_MAX_CHANNELS,
         .periods_min = 2,
         .periods_max = 512,
         .fifo_size = 0
 };
 
-static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes_old = {
-        .count = ARRAY_SIZE(period_sizes_old),
-        .list = period_sizes_old,
-        .mask = 0
-};
-
-static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes_new = {
-        .count = ARRAY_SIZE(period_sizes_new),
-        .list = period_sizes_new,
-        .mask = 0
-};
-
-static struct snd_pcm_hw_constraint_list hw_constraints_raydat_io_buffer = {
-        .count = ARRAY_SIZE(raydat_aio_buffer_sizes),
-        .list = raydat_aio_buffer_sizes,
-        .mask = 0
-};
-
 static int snd_hdspm_hw_rule_in_channels_rate(struct snd_pcm_hw_params *params,
                                            struct snd_pcm_hw_rule *rule)
 {
@@ -5953,26 +5955,29 @@ static int snd_hdspm_playback_open(struct snd_pcm_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_list(runtime, 0,
-                                SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
-                                &hw_constraints_period_sizes_new);
-                snd_pcm_hw_constraint_list(runtime, 0,
-                                SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
-                                &hw_constraints_raydat_io_buffer);
-
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+                                             32, 4096);
+                /* RayDAT & AIO have a fixed buffer of 16384 samples per channel */
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
+                                             16384, 16384);
                 break;
 
         default:
-                snd_pcm_hw_constraint_list(runtime, 0,
-                                SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
-                                &hw_constraints_period_sizes_old);
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+                                             64, 8192);
+                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);
         } else {
@@ -6025,24 +6030,28 @@ static int snd_hdspm_capture_open(struct snd_pcm_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_list(runtime, 0,
-                                     SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
-                                     &hw_constraints_period_sizes_new);
-          snd_pcm_hw_constraint_list(runtime, 0,
-                                     SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
-                                     &hw_constraints_raydat_io_buffer);
-          break;
+                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_list(runtime, 0,
-                                     SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
-                                     &hw_constraints_period_sizes_old);
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
+                                             64, 8192);
+                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);
         } else {
@@ -6088,7 +6097,7 @@ static inline int copy_u32_le(void __user *dest, void __iomem *src)
 }
 
 static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
-                unsigned int cmd, unsigned long __user arg)
+                unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         struct hdspm *hdspm = hw->private_data;
@@ -6213,11 +6222,13 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
                 info.line_out = hdspm_line_out(hdspm);
                 info.passthru = 0;
                 spin_unlock_irq(&hdspm->lock);
-                if (copy_to_user((void __user *) arg, &info, sizeof(info)))
+                if (copy_to_user(argp, &info, sizeof(info)))
                         return -EFAULT;
                 break;
 
         case SNDRV_HDSPM_IOCTL_GET_STATUS:
+                memset(&status, 0, sizeof(status));
+
                 status.card_type = hdspm->io_type;
 
                 status.autosync_source = hdspm_autosync_ref(hdspm);
@@ -6250,13 +6261,15 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
                         break;
                 }
 
-                if (copy_to_user((void __user *) arg, &status, sizeof(status)))
+                if (copy_to_user(argp, &status, sizeof(status)))
                         return -EFAULT;
 
 
                 break;
 
         case SNDRV_HDSPM_IOCTL_GET_VERSION:
+                memset(&hdspm_version, 0, sizeof(hdspm_version));
+
                 hdspm_version.card_type = hdspm->io_type;
                 strncpy(hdspm_version.cardname, hdspm->card_name,
                                 sizeof(hdspm_version.cardname));
@@ -6267,13 +6280,13 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
                 if (hdspm->tco)
                         hdspm_version.addons |= HDSPM_ADDON_TCO;
 
-                if (copy_to_user((void __user *) arg, &hdspm_version,
+                if (copy_to_user(argp, &hdspm_version,
                                         sizeof(hdspm_version)))
                         return -EFAULT;
                 break;
 
         case SNDRV_HDSPM_IOCTL_GET_MIXER:
-                if (copy_from_user(&mixer, (void __user *)arg, sizeof(mixer)))
+                if (copy_from_user(&mixer, argp, sizeof(mixer)))
                         return -EFAULT;
                 if (copy_to_user((void __user *)mixer.mixer, hdspm->mixer,
                                         sizeof(struct hdspm_mixer)))