Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * C-Media CMI8788 driver - mixer code
0004  *
0005  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
0006  */
0007 
0008 #include <linux/mutex.h>
0009 #include <sound/ac97_codec.h>
0010 #include <sound/asoundef.h>
0011 #include <sound/control.h>
0012 #include <sound/tlv.h>
0013 #include "oxygen.h"
0014 #include "cm9780.h"
0015 
0016 static int dac_volume_info(struct snd_kcontrol *ctl,
0017                struct snd_ctl_elem_info *info)
0018 {
0019     struct oxygen *chip = ctl->private_data;
0020 
0021     info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0022     info->count = chip->model.dac_channels_mixer;
0023     info->value.integer.min = chip->model.dac_volume_min;
0024     info->value.integer.max = chip->model.dac_volume_max;
0025     return 0;
0026 }
0027 
0028 static int dac_volume_get(struct snd_kcontrol *ctl,
0029               struct snd_ctl_elem_value *value)
0030 {
0031     struct oxygen *chip = ctl->private_data;
0032     unsigned int i;
0033 
0034     mutex_lock(&chip->mutex);
0035     for (i = 0; i < chip->model.dac_channels_mixer; ++i)
0036         value->value.integer.value[i] = chip->dac_volume[i];
0037     mutex_unlock(&chip->mutex);
0038     return 0;
0039 }
0040 
0041 static int dac_volume_put(struct snd_kcontrol *ctl,
0042               struct snd_ctl_elem_value *value)
0043 {
0044     struct oxygen *chip = ctl->private_data;
0045     unsigned int i;
0046     int changed;
0047 
0048     changed = 0;
0049     mutex_lock(&chip->mutex);
0050     for (i = 0; i < chip->model.dac_channels_mixer; ++i)
0051         if (value->value.integer.value[i] != chip->dac_volume[i]) {
0052             chip->dac_volume[i] = value->value.integer.value[i];
0053             changed = 1;
0054         }
0055     if (changed)
0056         chip->model.update_dac_volume(chip);
0057     mutex_unlock(&chip->mutex);
0058     return changed;
0059 }
0060 
0061 static int dac_mute_get(struct snd_kcontrol *ctl,
0062             struct snd_ctl_elem_value *value)
0063 {
0064     struct oxygen *chip = ctl->private_data;
0065 
0066     mutex_lock(&chip->mutex);
0067     value->value.integer.value[0] = !chip->dac_mute;
0068     mutex_unlock(&chip->mutex);
0069     return 0;
0070 }
0071 
0072 static int dac_mute_put(struct snd_kcontrol *ctl,
0073               struct snd_ctl_elem_value *value)
0074 {
0075     struct oxygen *chip = ctl->private_data;
0076     int changed;
0077 
0078     mutex_lock(&chip->mutex);
0079     changed = (!value->value.integer.value[0]) != chip->dac_mute;
0080     if (changed) {
0081         chip->dac_mute = !value->value.integer.value[0];
0082         chip->model.update_dac_mute(chip);
0083     }
0084     mutex_unlock(&chip->mutex);
0085     return changed;
0086 }
0087 
0088 static unsigned int upmix_item_count(struct oxygen *chip)
0089 {
0090     if (chip->model.dac_channels_pcm < 8)
0091         return 2;
0092     else if (chip->model.update_center_lfe_mix)
0093         return 5;
0094     else
0095         return 3;
0096 }
0097 
0098 static int upmix_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
0099 {
0100     static const char *const names[5] = {
0101         "Front",
0102         "Front+Surround",
0103         "Front+Surround+Back",
0104         "Front+Surround+Center/LFE",
0105         "Front+Surround+Center/LFE+Back",
0106     };
0107     struct oxygen *chip = ctl->private_data;
0108     unsigned int count = upmix_item_count(chip);
0109 
0110     return snd_ctl_enum_info(info, 1, count, names);
0111 }
0112 
0113 static int upmix_get(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
0114 {
0115     struct oxygen *chip = ctl->private_data;
0116 
0117     mutex_lock(&chip->mutex);
0118     value->value.enumerated.item[0] = chip->dac_routing;
0119     mutex_unlock(&chip->mutex);
0120     return 0;
0121 }
0122 
0123 void oxygen_update_dac_routing(struct oxygen *chip)
0124 {
0125     /* DAC 0: front, DAC 1: surround, DAC 2: center/LFE, DAC 3: back */
0126     static const unsigned int reg_values[5] = {
0127         /* stereo -> front */
0128         (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0129         (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0130         (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0131         (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
0132         /* stereo -> front+surround */
0133         (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0134         (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0135         (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0136         (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
0137         /* stereo -> front+surround+back */
0138         (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0139         (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0140         (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0141         (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
0142         /* stereo -> front+surround+center/LFE */
0143         (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0144         (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0145         (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0146         (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
0147         /* stereo -> front+surround+center/LFE+back */
0148         (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0149         (0 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0150         (0 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0151         (0 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT),
0152     };
0153     u8 channels;
0154     unsigned int reg_value;
0155 
0156     channels = oxygen_read8(chip, OXYGEN_PLAY_CHANNELS) &
0157         OXYGEN_PLAY_CHANNELS_MASK;
0158     if (channels == OXYGEN_PLAY_CHANNELS_2)
0159         reg_value = reg_values[chip->dac_routing];
0160     else if (channels == OXYGEN_PLAY_CHANNELS_8)
0161         /* in 7.1 mode, "rear" channels go to the "back" jack */
0162         reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0163                 (3 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0164                 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0165                 (1 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT);
0166     else
0167         reg_value = (0 << OXYGEN_PLAY_DAC0_SOURCE_SHIFT) |
0168                 (1 << OXYGEN_PLAY_DAC1_SOURCE_SHIFT) |
0169                 (2 << OXYGEN_PLAY_DAC2_SOURCE_SHIFT) |
0170                 (3 << OXYGEN_PLAY_DAC3_SOURCE_SHIFT);
0171     if (chip->model.adjust_dac_routing)
0172         reg_value = chip->model.adjust_dac_routing(chip, reg_value);
0173     oxygen_write16_masked(chip, OXYGEN_PLAY_ROUTING, reg_value,
0174                   OXYGEN_PLAY_DAC0_SOURCE_MASK |
0175                   OXYGEN_PLAY_DAC1_SOURCE_MASK |
0176                   OXYGEN_PLAY_DAC2_SOURCE_MASK |
0177                   OXYGEN_PLAY_DAC3_SOURCE_MASK);
0178     if (chip->model.update_center_lfe_mix)
0179         chip->model.update_center_lfe_mix(chip, chip->dac_routing > 2);
0180 }
0181 EXPORT_SYMBOL(oxygen_update_dac_routing);
0182 
0183 static int upmix_put(struct snd_kcontrol *ctl, struct snd_ctl_elem_value *value)
0184 {
0185     struct oxygen *chip = ctl->private_data;
0186     unsigned int count = upmix_item_count(chip);
0187     int changed;
0188 
0189     if (value->value.enumerated.item[0] >= count)
0190         return -EINVAL;
0191     mutex_lock(&chip->mutex);
0192     changed = value->value.enumerated.item[0] != chip->dac_routing;
0193     if (changed) {
0194         chip->dac_routing = value->value.enumerated.item[0];
0195         oxygen_update_dac_routing(chip);
0196     }
0197     mutex_unlock(&chip->mutex);
0198     return changed;
0199 }
0200 
0201 static int spdif_switch_get(struct snd_kcontrol *ctl,
0202                 struct snd_ctl_elem_value *value)
0203 {
0204     struct oxygen *chip = ctl->private_data;
0205 
0206     mutex_lock(&chip->mutex);
0207     value->value.integer.value[0] = chip->spdif_playback_enable;
0208     mutex_unlock(&chip->mutex);
0209     return 0;
0210 }
0211 
0212 static unsigned int oxygen_spdif_rate(unsigned int oxygen_rate)
0213 {
0214     switch (oxygen_rate) {
0215     case OXYGEN_RATE_32000:
0216         return IEC958_AES3_CON_FS_32000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0217     case OXYGEN_RATE_44100:
0218         return IEC958_AES3_CON_FS_44100 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0219     default: /* OXYGEN_RATE_48000 */
0220         return IEC958_AES3_CON_FS_48000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0221     case OXYGEN_RATE_64000:
0222         return 0xb << OXYGEN_SPDIF_CS_RATE_SHIFT;
0223     case OXYGEN_RATE_88200:
0224         return IEC958_AES3_CON_FS_88200 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0225     case OXYGEN_RATE_96000:
0226         return IEC958_AES3_CON_FS_96000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0227     case OXYGEN_RATE_176400:
0228         return IEC958_AES3_CON_FS_176400 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0229     case OXYGEN_RATE_192000:
0230         return IEC958_AES3_CON_FS_192000 << OXYGEN_SPDIF_CS_RATE_SHIFT;
0231     }
0232 }
0233 
0234 void oxygen_update_spdif_source(struct oxygen *chip)
0235 {
0236     u32 old_control, new_control;
0237     u16 old_routing, new_routing;
0238     unsigned int oxygen_rate;
0239 
0240     old_control = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
0241     old_routing = oxygen_read16(chip, OXYGEN_PLAY_ROUTING);
0242     if (chip->pcm_active & (1 << PCM_SPDIF)) {
0243         new_control = old_control | OXYGEN_SPDIF_OUT_ENABLE;
0244         new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK)
0245             | OXYGEN_PLAY_SPDIF_SPDIF;
0246         oxygen_rate = (old_control >> OXYGEN_SPDIF_OUT_RATE_SHIFT)
0247             & OXYGEN_I2S_RATE_MASK;
0248         /* S/PDIF rate was already set by the caller */
0249     } else if ((chip->pcm_active & (1 << PCM_MULTICH)) &&
0250            chip->spdif_playback_enable) {
0251         new_routing = (old_routing & ~OXYGEN_PLAY_SPDIF_MASK)
0252             | OXYGEN_PLAY_SPDIF_MULTICH_01;
0253         oxygen_rate = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT)
0254             & OXYGEN_I2S_RATE_MASK;
0255         new_control = (old_control & ~OXYGEN_SPDIF_OUT_RATE_MASK) |
0256             (oxygen_rate << OXYGEN_SPDIF_OUT_RATE_SHIFT) |
0257             OXYGEN_SPDIF_OUT_ENABLE;
0258     } else {
0259         new_control = old_control & ~OXYGEN_SPDIF_OUT_ENABLE;
0260         new_routing = old_routing;
0261         oxygen_rate = OXYGEN_RATE_44100;
0262     }
0263     if (old_routing != new_routing) {
0264         oxygen_write32(chip, OXYGEN_SPDIF_CONTROL,
0265                    new_control & ~OXYGEN_SPDIF_OUT_ENABLE);
0266         oxygen_write16(chip, OXYGEN_PLAY_ROUTING, new_routing);
0267     }
0268     if (new_control & OXYGEN_SPDIF_OUT_ENABLE)
0269         oxygen_write32(chip, OXYGEN_SPDIF_OUTPUT_BITS,
0270                    oxygen_spdif_rate(oxygen_rate) |
0271                    ((chip->pcm_active & (1 << PCM_SPDIF)) ?
0272                 chip->spdif_pcm_bits : chip->spdif_bits));
0273     oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, new_control);
0274 }
0275 
0276 static int spdif_switch_put(struct snd_kcontrol *ctl,
0277                 struct snd_ctl_elem_value *value)
0278 {
0279     struct oxygen *chip = ctl->private_data;
0280     int changed;
0281 
0282     mutex_lock(&chip->mutex);
0283     changed = value->value.integer.value[0] != chip->spdif_playback_enable;
0284     if (changed) {
0285         chip->spdif_playback_enable = !!value->value.integer.value[0];
0286         spin_lock_irq(&chip->reg_lock);
0287         oxygen_update_spdif_source(chip);
0288         spin_unlock_irq(&chip->reg_lock);
0289     }
0290     mutex_unlock(&chip->mutex);
0291     return changed;
0292 }
0293 
0294 static int spdif_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
0295 {
0296     info->type = SNDRV_CTL_ELEM_TYPE_IEC958;
0297     info->count = 1;
0298     return 0;
0299 }
0300 
0301 static void oxygen_to_iec958(u32 bits, struct snd_ctl_elem_value *value)
0302 {
0303     value->value.iec958.status[0] =
0304         bits & (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
0305             OXYGEN_SPDIF_PREEMPHASIS);
0306     value->value.iec958.status[1] = /* category and original */
0307         bits >> OXYGEN_SPDIF_CATEGORY_SHIFT;
0308 }
0309 
0310 static u32 iec958_to_oxygen(struct snd_ctl_elem_value *value)
0311 {
0312     u32 bits;
0313 
0314     bits = value->value.iec958.status[0] &
0315         (OXYGEN_SPDIF_NONAUDIO | OXYGEN_SPDIF_C |
0316          OXYGEN_SPDIF_PREEMPHASIS);
0317     bits |= value->value.iec958.status[1] << OXYGEN_SPDIF_CATEGORY_SHIFT;
0318     if (bits & OXYGEN_SPDIF_NONAUDIO)
0319         bits |= OXYGEN_SPDIF_V;
0320     return bits;
0321 }
0322 
0323 static inline void write_spdif_bits(struct oxygen *chip, u32 bits)
0324 {
0325     oxygen_write32_masked(chip, OXYGEN_SPDIF_OUTPUT_BITS, bits,
0326                   OXYGEN_SPDIF_NONAUDIO |
0327                   OXYGEN_SPDIF_C |
0328                   OXYGEN_SPDIF_PREEMPHASIS |
0329                   OXYGEN_SPDIF_CATEGORY_MASK |
0330                   OXYGEN_SPDIF_ORIGINAL |
0331                   OXYGEN_SPDIF_V);
0332 }
0333 
0334 static int spdif_default_get(struct snd_kcontrol *ctl,
0335                  struct snd_ctl_elem_value *value)
0336 {
0337     struct oxygen *chip = ctl->private_data;
0338 
0339     mutex_lock(&chip->mutex);
0340     oxygen_to_iec958(chip->spdif_bits, value);
0341     mutex_unlock(&chip->mutex);
0342     return 0;
0343 }
0344 
0345 static int spdif_default_put(struct snd_kcontrol *ctl,
0346                  struct snd_ctl_elem_value *value)
0347 {
0348     struct oxygen *chip = ctl->private_data;
0349     u32 new_bits;
0350     int changed;
0351 
0352     new_bits = iec958_to_oxygen(value);
0353     mutex_lock(&chip->mutex);
0354     changed = new_bits != chip->spdif_bits;
0355     if (changed) {
0356         chip->spdif_bits = new_bits;
0357         if (!(chip->pcm_active & (1 << PCM_SPDIF)))
0358             write_spdif_bits(chip, new_bits);
0359     }
0360     mutex_unlock(&chip->mutex);
0361     return changed;
0362 }
0363 
0364 static int spdif_mask_get(struct snd_kcontrol *ctl,
0365               struct snd_ctl_elem_value *value)
0366 {
0367     value->value.iec958.status[0] = IEC958_AES0_NONAUDIO |
0368         IEC958_AES0_CON_NOT_COPYRIGHT | IEC958_AES0_CON_EMPHASIS;
0369     value->value.iec958.status[1] =
0370         IEC958_AES1_CON_CATEGORY | IEC958_AES1_CON_ORIGINAL;
0371     return 0;
0372 }
0373 
0374 static int spdif_pcm_get(struct snd_kcontrol *ctl,
0375              struct snd_ctl_elem_value *value)
0376 {
0377     struct oxygen *chip = ctl->private_data;
0378 
0379     mutex_lock(&chip->mutex);
0380     oxygen_to_iec958(chip->spdif_pcm_bits, value);
0381     mutex_unlock(&chip->mutex);
0382     return 0;
0383 }
0384 
0385 static int spdif_pcm_put(struct snd_kcontrol *ctl,
0386              struct snd_ctl_elem_value *value)
0387 {
0388     struct oxygen *chip = ctl->private_data;
0389     u32 new_bits;
0390     int changed;
0391 
0392     new_bits = iec958_to_oxygen(value);
0393     mutex_lock(&chip->mutex);
0394     changed = new_bits != chip->spdif_pcm_bits;
0395     if (changed) {
0396         chip->spdif_pcm_bits = new_bits;
0397         if (chip->pcm_active & (1 << PCM_SPDIF))
0398             write_spdif_bits(chip, new_bits);
0399     }
0400     mutex_unlock(&chip->mutex);
0401     return changed;
0402 }
0403 
0404 static int spdif_input_mask_get(struct snd_kcontrol *ctl,
0405                 struct snd_ctl_elem_value *value)
0406 {
0407     value->value.iec958.status[0] = 0xff;
0408     value->value.iec958.status[1] = 0xff;
0409     value->value.iec958.status[2] = 0xff;
0410     value->value.iec958.status[3] = 0xff;
0411     return 0;
0412 }
0413 
0414 static int spdif_input_default_get(struct snd_kcontrol *ctl,
0415                    struct snd_ctl_elem_value *value)
0416 {
0417     struct oxygen *chip = ctl->private_data;
0418     u32 bits;
0419 
0420     bits = oxygen_read32(chip, OXYGEN_SPDIF_INPUT_BITS);
0421     value->value.iec958.status[0] = bits;
0422     value->value.iec958.status[1] = bits >> 8;
0423     value->value.iec958.status[2] = bits >> 16;
0424     value->value.iec958.status[3] = bits >> 24;
0425     return 0;
0426 }
0427 
0428 static int spdif_bit_switch_get(struct snd_kcontrol *ctl,
0429                 struct snd_ctl_elem_value *value)
0430 {
0431     struct oxygen *chip = ctl->private_data;
0432     u32 bit = ctl->private_value;
0433 
0434     value->value.integer.value[0] =
0435         !!(oxygen_read32(chip, OXYGEN_SPDIF_CONTROL) & bit);
0436     return 0;
0437 }
0438 
0439 static int spdif_bit_switch_put(struct snd_kcontrol *ctl,
0440                 struct snd_ctl_elem_value *value)
0441 {
0442     struct oxygen *chip = ctl->private_data;
0443     u32 bit = ctl->private_value;
0444     u32 oldreg, newreg;
0445     int changed;
0446 
0447     spin_lock_irq(&chip->reg_lock);
0448     oldreg = oxygen_read32(chip, OXYGEN_SPDIF_CONTROL);
0449     if (value->value.integer.value[0])
0450         newreg = oldreg | bit;
0451     else
0452         newreg = oldreg & ~bit;
0453     changed = newreg != oldreg;
0454     if (changed)
0455         oxygen_write32(chip, OXYGEN_SPDIF_CONTROL, newreg);
0456     spin_unlock_irq(&chip->reg_lock);
0457     return changed;
0458 }
0459 
0460 static int monitor_volume_info(struct snd_kcontrol *ctl,
0461                    struct snd_ctl_elem_info *info)
0462 {
0463     info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0464     info->count = 1;
0465     info->value.integer.min = 0;
0466     info->value.integer.max = 1;
0467     return 0;
0468 }
0469 
0470 static int monitor_get(struct snd_kcontrol *ctl,
0471                struct snd_ctl_elem_value *value)
0472 {
0473     struct oxygen *chip = ctl->private_data;
0474     u8 bit = ctl->private_value;
0475     int invert = ctl->private_value & (1 << 8);
0476 
0477     value->value.integer.value[0] =
0478         !!invert ^ !!(oxygen_read8(chip, OXYGEN_ADC_MONITOR) & bit);
0479     return 0;
0480 }
0481 
0482 static int monitor_put(struct snd_kcontrol *ctl,
0483                struct snd_ctl_elem_value *value)
0484 {
0485     struct oxygen *chip = ctl->private_data;
0486     u8 bit = ctl->private_value;
0487     int invert = ctl->private_value & (1 << 8);
0488     u8 oldreg, newreg;
0489     int changed;
0490 
0491     spin_lock_irq(&chip->reg_lock);
0492     oldreg = oxygen_read8(chip, OXYGEN_ADC_MONITOR);
0493     if ((!!value->value.integer.value[0] ^ !!invert) != 0)
0494         newreg = oldreg | bit;
0495     else
0496         newreg = oldreg & ~bit;
0497     changed = newreg != oldreg;
0498     if (changed)
0499         oxygen_write8(chip, OXYGEN_ADC_MONITOR, newreg);
0500     spin_unlock_irq(&chip->reg_lock);
0501     return changed;
0502 }
0503 
0504 static int ac97_switch_get(struct snd_kcontrol *ctl,
0505                struct snd_ctl_elem_value *value)
0506 {
0507     struct oxygen *chip = ctl->private_data;
0508     unsigned int codec = (ctl->private_value >> 24) & 1;
0509     unsigned int index = ctl->private_value & 0xff;
0510     unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
0511     int invert = ctl->private_value & (1 << 16);
0512     u16 reg;
0513 
0514     mutex_lock(&chip->mutex);
0515     reg = oxygen_read_ac97(chip, codec, index);
0516     mutex_unlock(&chip->mutex);
0517     if (!(reg & (1 << bitnr)) ^ !invert)
0518         value->value.integer.value[0] = 1;
0519     else
0520         value->value.integer.value[0] = 0;
0521     return 0;
0522 }
0523 
0524 static void mute_ac97_ctl(struct oxygen *chip, unsigned int control)
0525 {
0526     unsigned int priv_idx;
0527     u16 value;
0528 
0529     if (!chip->controls[control])
0530         return;
0531     priv_idx = chip->controls[control]->private_value & 0xff;
0532     value = oxygen_read_ac97(chip, 0, priv_idx);
0533     if (!(value & 0x8000)) {
0534         oxygen_write_ac97(chip, 0, priv_idx, value | 0x8000);
0535         if (chip->model.ac97_switch)
0536             chip->model.ac97_switch(chip, priv_idx, 0x8000);
0537         snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
0538                    &chip->controls[control]->id);
0539     }
0540 }
0541 
0542 static int ac97_switch_put(struct snd_kcontrol *ctl,
0543                struct snd_ctl_elem_value *value)
0544 {
0545     struct oxygen *chip = ctl->private_data;
0546     unsigned int codec = (ctl->private_value >> 24) & 1;
0547     unsigned int index = ctl->private_value & 0xff;
0548     unsigned int bitnr = (ctl->private_value >> 8) & 0xff;
0549     int invert = ctl->private_value & (1 << 16);
0550     u16 oldreg, newreg;
0551     int change;
0552 
0553     mutex_lock(&chip->mutex);
0554     oldreg = oxygen_read_ac97(chip, codec, index);
0555     newreg = oldreg;
0556     if (!value->value.integer.value[0] ^ !invert)
0557         newreg |= 1 << bitnr;
0558     else
0559         newreg &= ~(1 << bitnr);
0560     change = newreg != oldreg;
0561     if (change) {
0562         oxygen_write_ac97(chip, codec, index, newreg);
0563         if (codec == 0 && chip->model.ac97_switch)
0564             chip->model.ac97_switch(chip, index, newreg & 0x8000);
0565         if (index == AC97_LINE) {
0566             oxygen_write_ac97_masked(chip, 0, CM9780_GPIO_STATUS,
0567                          newreg & 0x8000 ?
0568                          CM9780_GPO0 : 0, CM9780_GPO0);
0569             if (!(newreg & 0x8000)) {
0570                 mute_ac97_ctl(chip, CONTROL_MIC_CAPTURE_SWITCH);
0571                 mute_ac97_ctl(chip, CONTROL_CD_CAPTURE_SWITCH);
0572                 mute_ac97_ctl(chip, CONTROL_AUX_CAPTURE_SWITCH);
0573             }
0574         } else if ((index == AC97_MIC || index == AC97_CD ||
0575                 index == AC97_VIDEO || index == AC97_AUX) &&
0576                bitnr == 15 && !(newreg & 0x8000)) {
0577             mute_ac97_ctl(chip, CONTROL_LINE_CAPTURE_SWITCH);
0578             oxygen_write_ac97_masked(chip, 0, CM9780_GPIO_STATUS,
0579                          CM9780_GPO0, CM9780_GPO0);
0580         }
0581     }
0582     mutex_unlock(&chip->mutex);
0583     return change;
0584 }
0585 
0586 static int ac97_volume_info(struct snd_kcontrol *ctl,
0587                 struct snd_ctl_elem_info *info)
0588 {
0589     int stereo = (ctl->private_value >> 16) & 1;
0590 
0591     info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0592     info->count = stereo ? 2 : 1;
0593     info->value.integer.min = 0;
0594     info->value.integer.max = 0x1f;
0595     return 0;
0596 }
0597 
0598 static int ac97_volume_get(struct snd_kcontrol *ctl,
0599                struct snd_ctl_elem_value *value)
0600 {
0601     struct oxygen *chip = ctl->private_data;
0602     unsigned int codec = (ctl->private_value >> 24) & 1;
0603     int stereo = (ctl->private_value >> 16) & 1;
0604     unsigned int index = ctl->private_value & 0xff;
0605     u16 reg;
0606 
0607     mutex_lock(&chip->mutex);
0608     reg = oxygen_read_ac97(chip, codec, index);
0609     mutex_unlock(&chip->mutex);
0610     if (!stereo) {
0611         value->value.integer.value[0] = 31 - (reg & 0x1f);
0612     } else {
0613         value->value.integer.value[0] = 31 - ((reg >> 8) & 0x1f);
0614         value->value.integer.value[1] = 31 - (reg & 0x1f);
0615     }
0616     return 0;
0617 }
0618 
0619 static int ac97_volume_put(struct snd_kcontrol *ctl,
0620                struct snd_ctl_elem_value *value)
0621 {
0622     struct oxygen *chip = ctl->private_data;
0623     unsigned int codec = (ctl->private_value >> 24) & 1;
0624     int stereo = (ctl->private_value >> 16) & 1;
0625     unsigned int index = ctl->private_value & 0xff;
0626     u16 oldreg, newreg;
0627     int change;
0628 
0629     mutex_lock(&chip->mutex);
0630     oldreg = oxygen_read_ac97(chip, codec, index);
0631     if (!stereo) {
0632         newreg = oldreg & ~0x1f;
0633         newreg |= 31 - (value->value.integer.value[0] & 0x1f);
0634     } else {
0635         newreg = oldreg & ~0x1f1f;
0636         newreg |= (31 - (value->value.integer.value[0] & 0x1f)) << 8;
0637         newreg |= 31 - (value->value.integer.value[1] & 0x1f);
0638     }
0639     change = newreg != oldreg;
0640     if (change)
0641         oxygen_write_ac97(chip, codec, index, newreg);
0642     mutex_unlock(&chip->mutex);
0643     return change;
0644 }
0645 
0646 static int mic_fmic_source_info(struct snd_kcontrol *ctl,
0647                struct snd_ctl_elem_info *info)
0648 {
0649     static const char *const names[] = { "Mic Jack", "Front Panel" };
0650 
0651     return snd_ctl_enum_info(info, 1, 2, names);
0652 }
0653 
0654 static int mic_fmic_source_get(struct snd_kcontrol *ctl,
0655                    struct snd_ctl_elem_value *value)
0656 {
0657     struct oxygen *chip = ctl->private_data;
0658 
0659     mutex_lock(&chip->mutex);
0660     value->value.enumerated.item[0] =
0661         !!(oxygen_read_ac97(chip, 0, CM9780_JACK) & CM9780_FMIC2MIC);
0662     mutex_unlock(&chip->mutex);
0663     return 0;
0664 }
0665 
0666 static int mic_fmic_source_put(struct snd_kcontrol *ctl,
0667                    struct snd_ctl_elem_value *value)
0668 {
0669     struct oxygen *chip = ctl->private_data;
0670     u16 oldreg, newreg;
0671     int change;
0672 
0673     mutex_lock(&chip->mutex);
0674     oldreg = oxygen_read_ac97(chip, 0, CM9780_JACK);
0675     if (value->value.enumerated.item[0])
0676         newreg = oldreg | CM9780_FMIC2MIC;
0677     else
0678         newreg = oldreg & ~CM9780_FMIC2MIC;
0679     change = newreg != oldreg;
0680     if (change)
0681         oxygen_write_ac97(chip, 0, CM9780_JACK, newreg);
0682     mutex_unlock(&chip->mutex);
0683     return change;
0684 }
0685 
0686 static int ac97_fp_rec_volume_info(struct snd_kcontrol *ctl,
0687                    struct snd_ctl_elem_info *info)
0688 {
0689     info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
0690     info->count = 2;
0691     info->value.integer.min = 0;
0692     info->value.integer.max = 7;
0693     return 0;
0694 }
0695 
0696 static int ac97_fp_rec_volume_get(struct snd_kcontrol *ctl,
0697                   struct snd_ctl_elem_value *value)
0698 {
0699     struct oxygen *chip = ctl->private_data;
0700     u16 reg;
0701 
0702     mutex_lock(&chip->mutex);
0703     reg = oxygen_read_ac97(chip, 1, AC97_REC_GAIN);
0704     mutex_unlock(&chip->mutex);
0705     value->value.integer.value[0] = reg & 7;
0706     value->value.integer.value[1] = (reg >> 8) & 7;
0707     return 0;
0708 }
0709 
0710 static int ac97_fp_rec_volume_put(struct snd_kcontrol *ctl,
0711                   struct snd_ctl_elem_value *value)
0712 {
0713     struct oxygen *chip = ctl->private_data;
0714     u16 oldreg, newreg;
0715     int change;
0716 
0717     mutex_lock(&chip->mutex);
0718     oldreg = oxygen_read_ac97(chip, 1, AC97_REC_GAIN);
0719     newreg = oldreg & ~0x0707;
0720     newreg = newreg | (value->value.integer.value[0] & 7);
0721     newreg = newreg | ((value->value.integer.value[0] & 7) << 8);
0722     change = newreg != oldreg;
0723     if (change)
0724         oxygen_write_ac97(chip, 1, AC97_REC_GAIN, newreg);
0725     mutex_unlock(&chip->mutex);
0726     return change;
0727 }
0728 
0729 #define AC97_SWITCH(xname, codec, index, bitnr, invert) { \
0730         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
0731         .name = xname, \
0732         .info = snd_ctl_boolean_mono_info, \
0733         .get = ac97_switch_get, \
0734         .put = ac97_switch_put, \
0735         .private_value = ((codec) << 24) | ((invert) << 16) | \
0736                  ((bitnr) << 8) | (index), \
0737     }
0738 #define AC97_VOLUME(xname, codec, index, stereo) { \
0739         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
0740         .name = xname, \
0741         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \
0742               SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
0743         .info = ac97_volume_info, \
0744         .get = ac97_volume_get, \
0745         .put = ac97_volume_put, \
0746         .tlv = { .p = ac97_db_scale, }, \
0747         .private_value = ((codec) << 24) | ((stereo) << 16) | (index), \
0748     }
0749 
0750 static DECLARE_TLV_DB_SCALE(monitor_db_scale, -600, 600, 0);
0751 static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0);
0752 static DECLARE_TLV_DB_SCALE(ac97_rec_db_scale, 0, 150, 0);
0753 
0754 static const struct snd_kcontrol_new controls[] = {
0755     {
0756         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0757         .name = "Master Playback Volume",
0758         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
0759         .info = dac_volume_info,
0760         .get = dac_volume_get,
0761         .put = dac_volume_put,
0762     },
0763     {
0764         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0765         .name = "Master Playback Switch",
0766         .info = snd_ctl_boolean_mono_info,
0767         .get = dac_mute_get,
0768         .put = dac_mute_put,
0769     },
0770     {
0771         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0772         .name = "Stereo Upmixing",
0773         .info = upmix_info,
0774         .get = upmix_get,
0775         .put = upmix_put,
0776     },
0777 };
0778 
0779 static const struct snd_kcontrol_new spdif_output_controls[] = {
0780     {
0781         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0782         .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
0783         .info = snd_ctl_boolean_mono_info,
0784         .get = spdif_switch_get,
0785         .put = spdif_switch_put,
0786     },
0787     {
0788         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0789         .device = 1,
0790         .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, DEFAULT),
0791         .info = spdif_info,
0792         .get = spdif_default_get,
0793         .put = spdif_default_put,
0794     },
0795     {
0796         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0797         .device = 1,
0798         .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, CON_MASK),
0799         .access = SNDRV_CTL_ELEM_ACCESS_READ,
0800         .info = spdif_info,
0801         .get = spdif_mask_get,
0802     },
0803     {
0804         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0805         .device = 1,
0806         .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
0807         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
0808               SNDRV_CTL_ELEM_ACCESS_INACTIVE,
0809         .info = spdif_info,
0810         .get = spdif_pcm_get,
0811         .put = spdif_pcm_put,
0812     },
0813 };
0814 
0815 static const struct snd_kcontrol_new spdif_input_controls[] = {
0816     {
0817         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0818         .device = 1,
0819         .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, MASK),
0820         .access = SNDRV_CTL_ELEM_ACCESS_READ,
0821         .info = spdif_info,
0822         .get = spdif_input_mask_get,
0823     },
0824     {
0825         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
0826         .device = 1,
0827         .name = SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
0828         .access = SNDRV_CTL_ELEM_ACCESS_READ,
0829         .info = spdif_info,
0830         .get = spdif_input_default_get,
0831     },
0832     {
0833         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0834         .name = SNDRV_CTL_NAME_IEC958("Loopback ", NONE, SWITCH),
0835         .info = snd_ctl_boolean_mono_info,
0836         .get = spdif_bit_switch_get,
0837         .put = spdif_bit_switch_put,
0838         .private_value = OXYGEN_SPDIF_LOOPBACK,
0839     },
0840     {
0841         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0842         .name = SNDRV_CTL_NAME_IEC958("Validity Check ",CAPTURE,SWITCH),
0843         .info = snd_ctl_boolean_mono_info,
0844         .get = spdif_bit_switch_get,
0845         .put = spdif_bit_switch_put,
0846         .private_value = OXYGEN_SPDIF_SPDVALID,
0847     },
0848 };
0849 
0850 static const struct {
0851     unsigned int pcm_dev;
0852     struct snd_kcontrol_new controls[2];
0853 } monitor_controls[] = {
0854     {
0855         .pcm_dev = CAPTURE_0_FROM_I2S_1,
0856         .controls = {
0857             {
0858                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0859                 .name = "Analog Input Monitor Playback Switch",
0860                 .info = snd_ctl_boolean_mono_info,
0861                 .get = monitor_get,
0862                 .put = monitor_put,
0863                 .private_value = OXYGEN_ADC_MONITOR_A,
0864             },
0865             {
0866                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0867                 .name = "Analog Input Monitor Playback Volume",
0868                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
0869                       SNDRV_CTL_ELEM_ACCESS_TLV_READ,
0870                 .info = monitor_volume_info,
0871                 .get = monitor_get,
0872                 .put = monitor_put,
0873                 .private_value = OXYGEN_ADC_MONITOR_A_HALF_VOL
0874                         | (1 << 8),
0875                 .tlv = { .p = monitor_db_scale, },
0876             },
0877         },
0878     },
0879     {
0880         .pcm_dev = CAPTURE_0_FROM_I2S_2,
0881         .controls = {
0882             {
0883                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0884                 .name = "Analog Input Monitor Playback Switch",
0885                 .info = snd_ctl_boolean_mono_info,
0886                 .get = monitor_get,
0887                 .put = monitor_put,
0888                 .private_value = OXYGEN_ADC_MONITOR_B,
0889             },
0890             {
0891                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0892                 .name = "Analog Input Monitor Playback Volume",
0893                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
0894                       SNDRV_CTL_ELEM_ACCESS_TLV_READ,
0895                 .info = monitor_volume_info,
0896                 .get = monitor_get,
0897                 .put = monitor_put,
0898                 .private_value = OXYGEN_ADC_MONITOR_B_HALF_VOL
0899                         | (1 << 8),
0900                 .tlv = { .p = monitor_db_scale, },
0901             },
0902         },
0903     },
0904     {
0905         .pcm_dev = CAPTURE_2_FROM_I2S_2,
0906         .controls = {
0907             {
0908                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0909                 .name = "Analog Input Monitor Playback Switch",
0910                 .index = 1,
0911                 .info = snd_ctl_boolean_mono_info,
0912                 .get = monitor_get,
0913                 .put = monitor_put,
0914                 .private_value = OXYGEN_ADC_MONITOR_B,
0915             },
0916             {
0917                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0918                 .name = "Analog Input Monitor Playback Volume",
0919                 .index = 1,
0920                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
0921                       SNDRV_CTL_ELEM_ACCESS_TLV_READ,
0922                 .info = monitor_volume_info,
0923                 .get = monitor_get,
0924                 .put = monitor_put,
0925                 .private_value = OXYGEN_ADC_MONITOR_B_HALF_VOL
0926                         | (1 << 8),
0927                 .tlv = { .p = monitor_db_scale, },
0928             },
0929         },
0930     },
0931     {
0932         .pcm_dev = CAPTURE_3_FROM_I2S_3,
0933         .controls = {
0934             {
0935                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0936                 .name = "Analog Input Monitor Playback Switch",
0937                 .index = 2,
0938                 .info = snd_ctl_boolean_mono_info,
0939                 .get = monitor_get,
0940                 .put = monitor_put,
0941                 .private_value = OXYGEN_ADC_MONITOR_C,
0942             },
0943             {
0944                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0945                 .name = "Analog Input Monitor Playback Volume",
0946                 .index = 2,
0947                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
0948                       SNDRV_CTL_ELEM_ACCESS_TLV_READ,
0949                 .info = monitor_volume_info,
0950                 .get = monitor_get,
0951                 .put = monitor_put,
0952                 .private_value = OXYGEN_ADC_MONITOR_C_HALF_VOL
0953                         | (1 << 8),
0954                 .tlv = { .p = monitor_db_scale, },
0955             },
0956         },
0957     },
0958     {
0959         .pcm_dev = CAPTURE_1_FROM_SPDIF,
0960         .controls = {
0961             {
0962                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0963                 .name = "Digital Input Monitor Playback Switch",
0964                 .info = snd_ctl_boolean_mono_info,
0965                 .get = monitor_get,
0966                 .put = monitor_put,
0967                 .private_value = OXYGEN_ADC_MONITOR_C,
0968             },
0969             {
0970                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0971                 .name = "Digital Input Monitor Playback Volume",
0972                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
0973                       SNDRV_CTL_ELEM_ACCESS_TLV_READ,
0974                 .info = monitor_volume_info,
0975                 .get = monitor_get,
0976                 .put = monitor_put,
0977                 .private_value = OXYGEN_ADC_MONITOR_C_HALF_VOL
0978                         | (1 << 8),
0979                 .tlv = { .p = monitor_db_scale, },
0980             },
0981         },
0982     },
0983 };
0984 
0985 static const struct snd_kcontrol_new ac97_controls[] = {
0986     AC97_VOLUME("Mic Capture Volume", 0, AC97_MIC, 0),
0987     AC97_SWITCH("Mic Capture Switch", 0, AC97_MIC, 15, 1),
0988     AC97_SWITCH("Mic Boost (+20dB)", 0, AC97_MIC, 6, 0),
0989     {
0990         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0991         .name = "Mic Source Capture Enum",
0992         .info = mic_fmic_source_info,
0993         .get = mic_fmic_source_get,
0994         .put = mic_fmic_source_put,
0995     },
0996     AC97_SWITCH("Line Capture Switch", 0, AC97_LINE, 15, 1),
0997     AC97_VOLUME("CD Capture Volume", 0, AC97_CD, 1),
0998     AC97_SWITCH("CD Capture Switch", 0, AC97_CD, 15, 1),
0999     AC97_VOLUME("Aux Capture Volume", 0, AC97_AUX, 1),
1000     AC97_SWITCH("Aux Capture Switch", 0, AC97_AUX, 15, 1),
1001 };
1002 
1003 static const struct snd_kcontrol_new ac97_fp_controls[] = {
1004     AC97_VOLUME("Front Panel Playback Volume", 1, AC97_HEADPHONE, 1),
1005     AC97_SWITCH("Front Panel Playback Switch", 1, AC97_HEADPHONE, 15, 1),
1006     {
1007         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1008         .name = "Front Panel Capture Volume",
1009         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1010               SNDRV_CTL_ELEM_ACCESS_TLV_READ,
1011         .info = ac97_fp_rec_volume_info,
1012         .get = ac97_fp_rec_volume_get,
1013         .put = ac97_fp_rec_volume_put,
1014         .tlv = { .p = ac97_rec_db_scale, },
1015     },
1016     AC97_SWITCH("Front Panel Capture Switch", 1, AC97_REC_GAIN, 15, 1),
1017 };
1018 
1019 static void oxygen_any_ctl_free(struct snd_kcontrol *ctl)
1020 {
1021     struct oxygen *chip = ctl->private_data;
1022     unsigned int i;
1023 
1024     /* I'm too lazy to write a function for each control :-) */
1025     for (i = 0; i < ARRAY_SIZE(chip->controls); ++i)
1026         chip->controls[i] = NULL;
1027 }
1028 
1029 static int add_controls(struct oxygen *chip,
1030             const struct snd_kcontrol_new controls[],
1031             unsigned int count)
1032 {
1033     static const char *const known_ctl_names[CONTROL_COUNT] = {
1034         [CONTROL_SPDIF_PCM] =
1035             SNDRV_CTL_NAME_IEC958("", PLAYBACK, PCM_STREAM),
1036         [CONTROL_SPDIF_INPUT_BITS] =
1037             SNDRV_CTL_NAME_IEC958("", CAPTURE, DEFAULT),
1038         [CONTROL_MIC_CAPTURE_SWITCH] = "Mic Capture Switch",
1039         [CONTROL_LINE_CAPTURE_SWITCH] = "Line Capture Switch",
1040         [CONTROL_CD_CAPTURE_SWITCH] = "CD Capture Switch",
1041         [CONTROL_AUX_CAPTURE_SWITCH] = "Aux Capture Switch",
1042     };
1043     unsigned int i;
1044     struct snd_kcontrol_new template;
1045     struct snd_kcontrol *ctl;
1046     int j, err;
1047 
1048     for (i = 0; i < count; ++i) {
1049         template = controls[i];
1050         if (chip->model.control_filter) {
1051             err = chip->model.control_filter(&template);
1052             if (err < 0)
1053                 return err;
1054             if (err == 1)
1055                 continue;
1056         }
1057         if (!strcmp(template.name, "Stereo Upmixing") &&
1058             chip->model.dac_channels_pcm == 2)
1059             continue;
1060         if (!strcmp(template.name, "Mic Source Capture Enum") &&
1061             !(chip->model.device_config & AC97_FMIC_SWITCH))
1062             continue;
1063         if (!strncmp(template.name, "CD Capture ", 11) &&
1064             !(chip->model.device_config & AC97_CD_INPUT))
1065             continue;
1066         if (!strcmp(template.name, "Master Playback Volume") &&
1067             chip->model.dac_tlv) {
1068             template.tlv.p = chip->model.dac_tlv;
1069             template.access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1070         }
1071         ctl = snd_ctl_new1(&template, chip);
1072         if (!ctl)
1073             return -ENOMEM;
1074         err = snd_ctl_add(chip->card, ctl);
1075         if (err < 0)
1076             return err;
1077         j = match_string(known_ctl_names, CONTROL_COUNT, ctl->id.name);
1078         if (j >= 0) {
1079             chip->controls[j] = ctl;
1080             ctl->private_free = oxygen_any_ctl_free;
1081         }
1082     }
1083     return 0;
1084 }
1085 
1086 int oxygen_mixer_init(struct oxygen *chip)
1087 {
1088     unsigned int i;
1089     int err;
1090 
1091     err = add_controls(chip, controls, ARRAY_SIZE(controls));
1092     if (err < 0)
1093         return err;
1094     if (chip->model.device_config & PLAYBACK_1_TO_SPDIF) {
1095         err = add_controls(chip, spdif_output_controls,
1096                    ARRAY_SIZE(spdif_output_controls));
1097         if (err < 0)
1098             return err;
1099     }
1100     if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) {
1101         err = add_controls(chip, spdif_input_controls,
1102                    ARRAY_SIZE(spdif_input_controls));
1103         if (err < 0)
1104             return err;
1105     }
1106     for (i = 0; i < ARRAY_SIZE(monitor_controls); ++i) {
1107         if (!(chip->model.device_config & monitor_controls[i].pcm_dev))
1108             continue;
1109         err = add_controls(chip, monitor_controls[i].controls,
1110                    ARRAY_SIZE(monitor_controls[i].controls));
1111         if (err < 0)
1112             return err;
1113     }
1114     if (chip->has_ac97_0) {
1115         err = add_controls(chip, ac97_controls,
1116                    ARRAY_SIZE(ac97_controls));
1117         if (err < 0)
1118             return err;
1119     }
1120     if (chip->has_ac97_1) {
1121         err = add_controls(chip, ac97_fp_controls,
1122                    ARRAY_SIZE(ac97_fp_controls));
1123         if (err < 0)
1124             return err;
1125     }
1126     return chip->model.mixer_init ? chip->model.mixer_init(chip) : 0;
1127 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!