static int choose_rate(struct snd_pcm_substream *substream,
                       struct snd_pcm_hw_params *params, unsigned int best_rate)
 {
-       struct snd_interval *it;
+       const struct snd_interval *it;
        struct snd_pcm_hw_params *save;
        unsigned int rate, prev;
 
        if (save == NULL)
                return -ENOMEM;
        *save = *params;
-       it = hw_param_interval(save, SNDRV_PCM_HW_PARAM_RATE);
+       it = hw_param_interval_c(save, SNDRV_PCM_HW_PARAM_RATE);
 
        /* try multiples of the best rate */
        rate = best_rate;
 
                           struct snd_pcm_hw_rule *rule)
 {
        struct snd_interval *r = hw_param_interval(params, rule->var);
-       struct snd_interval *c;
+       const struct snd_interval *c;
        unsigned int rate_mask = 7, i;
        const u8 *sad, *eld = rule->private;
 
        sad = drm_eld_sad(eld);
        if (sad) {
-               c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
+               c = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 
                for (i = drm_eld_sad_count(eld); i > 0; i--, sad += 3) {
                        unsigned max_channels = sad_max_channels(sad);
                              struct snd_pcm_hw_rule *rule)
 {
        struct snd_interval *c = hw_param_interval(params, rule->var);
-       struct snd_interval *r;
+       const struct snd_interval *r;
        struct snd_interval t = { .min = 1, .max = 2, .integer = 1, };
        unsigned int i;
        const u8 *sad, *eld = rule->private;
                unsigned int rate_mask = 0;
 
                /* Convert the rate interval to a mask */
-               r = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
+               r = hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
                for (i = 0; i < ARRAY_SIZE(eld_rates); i++)
                        if (r->min <= eld_rates[i] && r->max >= eld_rates[i])
                                rate_mask |= BIT(i);
 
        unsigned int l = (unsigned long) rule->private;
        int width = l & 0xffff;
        unsigned int msbits = l >> 16;
-       struct snd_interval *i = hw_param_interval(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
+       const struct snd_interval *i =
+               hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS);
 
        if (!snd_interval_single(i))
                return 0;
 
                                  struct snd_pcm_hw_rule *rule)
 {
        unsigned int k;
-       struct snd_interval *i = hw_param_interval(params, rule->deps[0]);
+       const struct snd_interval *i =
+                               hw_param_interval_c(params, rule->deps[0]);
        struct snd_mask m;
        struct snd_mask *mask = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
        snd_mask_any(&m);