#define PCM_AC97       5
 #define PCM_COUNT      6
 
+enum {
+       CONTROL_SPDIF_PCM,
+       CONTROL_SPDIF_INPUT_BITS,
+       CONTROL_COUNT
+};
+
 #define OXYGEN_PCI_SUBID(sv, sd) \
        .vendor = PCI_VENDOR_ID_CMEDIA, \
        .device = 0x8788, \
        u32 spdif_bits;
        u32 spdif_pcm_bits;
        struct snd_pcm_substream *streams[PCM_COUNT];
-       struct snd_kcontrol *spdif_pcm_ctl;
-       struct snd_kcontrol *spdif_input_bits_ctl;
+       struct snd_kcontrol *controls[CONTROL_COUNT];
        struct work_struct spdif_input_bits_work;
 };
 
 
                }
        }
 
-       if (chip->spdif_input_bits_ctl) {
+       if (chip->controls[CONTROL_SPDIF_INPUT_BITS]) {
                spin_lock_irq(&chip->reg_lock);
                chip->interrupt_mask |= OXYGEN_INT_SPDIF_IN_CHANGE;
                oxygen_write16(chip, OXYGEN_INTERRUPT_MASK,
                spin_unlock_irq(&chip->reg_lock);
 
                snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
-                              &chip->spdif_input_bits_ctl->id);
+                              &chip->controls[CONTROL_SPDIF_INPUT_BITS]->id);
        }
 }
 
 
 static void oxygen_any_ctl_free(struct snd_kcontrol *ctl)
 {
        struct oxygen *chip = ctl->private_data;
+       unsigned int i;
 
        /* I'm too lazy to write a function for each control :-) */
-       chip->spdif_pcm_ctl = NULL;
-       chip->spdif_input_bits_ctl = NULL;
+       for (i = 0; i < ARRAY_SIZE(chip->controls); ++i)
+               chip->controls[i] = NULL;
 }
 
 int oxygen_mixer_init(struct oxygen *chip)
 {
-       unsigned int i;
+       static const char *const known_ctl_names[CONTROL_COUNT] = {
+               [CONTROL_SPDIF_PCM] =
+                       SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
+               [CONTROL_SPDIF_INPUT_BITS] =
+                       SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
+       };
+       unsigned int i, j;
        struct snd_kcontrol *ctl;
        int err;
 
                err = snd_ctl_add(chip->card, ctl);
                if (err < 0)
                        return err;
-               if (!strcmp(ctl->id.name,
-                           SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM))) {
-                       chip->spdif_pcm_ctl = ctl;
-                       ctl->private_free = oxygen_any_ctl_free;
-               } else if (!strcmp(ctl->id.name,
-                                SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT))) {
-                       chip->spdif_input_bits_ctl = ctl;
-                       ctl->private_free = oxygen_any_ctl_free;
-               }
+               for (j = 0; j < CONTROL_COUNT; ++j)
+                       if (!strcmp(ctl->id.name, known_ctl_names[j])) {
+                               chip->controls[j] = ctl;
+                               ctl->private_free = oxygen_any_ctl_free;
+                       }
        }
        return chip->model->mixer_init ? chip->model->mixer_init(chip) : 0;
 }
 
        chip->pcm_active |= 1 << channel;
        if (channel == PCM_SPDIF) {
                chip->spdif_pcm_bits = chip->spdif_bits;
-               chip->spdif_pcm_ctl->vd[0].access &=
+               chip->controls[CONTROL_SPDIF_PCM]->vd[0].access &=
                        ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
                snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE |
                               SNDRV_CTL_EVENT_MASK_INFO,
-                              &chip->spdif_pcm_ctl->id);
+                              &chip->controls[CONTROL_SPDIF_PCM]->id);
        }
        mutex_unlock(&chip->mutex);
 
        mutex_lock(&chip->mutex);
        chip->pcm_active &= ~(1 << channel);
        if (channel == PCM_SPDIF) {
-               chip->spdif_pcm_ctl->vd[0].access |=
+               chip->controls[CONTROL_SPDIF_PCM]->vd[0].access |=
                        SNDRV_CTL_ELEM_ACCESS_INACTIVE;
                snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE |
                               SNDRV_CTL_EVENT_MASK_INFO,
-                              &chip->spdif_pcm_ctl->id);
+                              &chip->controls[CONTROL_SPDIF_PCM]->id);
        }
        if (channel == PCM_SPDIF || channel == PCM_MULTICH)
                oxygen_update_spdif_source(chip);