Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * card driver for models with PCM1796 DACs (Xonar D2/D2X/HDAV1.3/ST/STX)
0004  *
0005  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
0006  */
0007 
0008 /*
0009  * Xonar D2/D2X
0010  * ------------
0011  *
0012  * CMI8788:
0013  *
0014  *   SPI 0 -> 1st PCM1796 (front)
0015  *   SPI 1 -> 2nd PCM1796 (surround)
0016  *   SPI 2 -> 3rd PCM1796 (center/LFE)
0017  *   SPI 4 -> 4th PCM1796 (back)
0018  *
0019  *   GPIO 2 -> M0 of CS5381
0020  *   GPIO 3 -> M1 of CS5381
0021  *   GPIO 5 <- external power present (D2X only)
0022  *   GPIO 7 -> ALT
0023  *   GPIO 8 -> enable output to speakers
0024  *
0025  * CM9780:
0026  *
0027  *   LINE_OUT -> input of ADC
0028  *
0029  *   AUX_IN   <- aux
0030  *   VIDEO_IN <- CD
0031  *   FMIC_IN  <- mic
0032  *
0033  *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
0034  */
0035 
0036 /*
0037  * Xonar HDAV1.3 (Deluxe)
0038  * ----------------------
0039  *
0040  * CMI8788:
0041  *
0042  *   I²C <-> PCM1796 (addr 1001100) (front)
0043  *
0044  *   GPI 0 <- external power present
0045  *
0046  *   GPIO 0 -> enable HDMI (0) or speaker (1) output
0047  *   GPIO 2 -> M0 of CS5381
0048  *   GPIO 3 -> M1 of CS5381
0049  *   GPIO 4 <- daughterboard detection
0050  *   GPIO 5 <- daughterboard detection
0051  *   GPIO 6 -> ?
0052  *   GPIO 7 -> ?
0053  *   GPIO 8 -> route input jack to line-in (0) or mic-in (1)
0054  *
0055  *   UART <-> HDMI controller
0056  *
0057  * CM9780:
0058  *
0059  *   LINE_OUT -> input of ADC
0060  *
0061  *   AUX_IN <- aux
0062  *   CD_IN  <- CD
0063  *   MIC_IN <- mic
0064  *
0065  *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
0066  *
0067  * no daughterboard
0068  * ----------------
0069  *
0070  *   GPIO 4 <- 1
0071  *
0072  * H6 daughterboard
0073  * ----------------
0074  *
0075  *   GPIO 4 <- 0
0076  *   GPIO 5 <- 0
0077  *
0078  *   I²C <-> PCM1796 (addr 1001101) (surround)
0079  *       <-> PCM1796 (addr 1001110) (center/LFE)
0080  *       <-> PCM1796 (addr 1001111) (back)
0081  *
0082  * unknown daughterboard
0083  * ---------------------
0084  *
0085  *   GPIO 4 <- 0
0086  *   GPIO 5 <- 1
0087  *
0088  *   I²C <-> CS4362A (addr 0011000) (surround, center/LFE, back)
0089  */
0090 
0091 /*
0092  * Xonar Essence ST (Deluxe)/STX (II)
0093  * ----------------------------------
0094  *
0095  * CMI8788:
0096  *
0097  *   I²C <-> PCM1792A (addr 1001100)
0098  *       <-> CS2000 (addr 1001110) (ST only)
0099  *
0100  *   ADC1 MCLK -> REF_CLK of CS2000 (ST only)
0101  *
0102  *   GPI 0 <- external power present (STX only)
0103  *
0104  *   GPIO 0 -> enable output to speakers
0105  *   GPIO 1 -> route HP to front panel (0) or rear jack (1)
0106  *   GPIO 2 -> M0 of CS5381
0107  *   GPIO 3 -> M1 of CS5381
0108  *   GPIO 4 <- daughterboard detection
0109  *   GPIO 5 <- daughterboard detection
0110  *   GPIO 6 -> ?
0111  *   GPIO 7 -> route output to speaker jacks (0) or HP (1)
0112  *   GPIO 8 -> route input jack to line-in (0) or mic-in (1)
0113  *
0114  * PCM1792A:
0115  *
0116  *   SCK <- CLK_OUT of CS2000 (ST only)
0117  *
0118  * CM9780:
0119  *
0120  *   LINE_OUT -> input of ADC
0121  *
0122  *   AUX_IN <- aux
0123  *   MIC_IN <- mic
0124  *
0125  *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
0126  *
0127  * H6 daughterboard
0128  * ----------------
0129  *
0130  * GPIO 4 <- 0
0131  * GPIO 5 <- 0
0132  */
0133 
0134 /*
0135  * Xonar Xense
0136  * -----------
0137  *
0138  * CMI8788:
0139  *
0140  *   I²C <-> PCM1796 (addr 1001100) (front)
0141  *       <-> CS4362A (addr 0011000) (surround, center/LFE, back)
0142  *       <-> CS2000 (addr 1001110)
0143  *
0144  *   ADC1 MCLK -> REF_CLK of CS2000
0145  *
0146  *   GPI 0 <- external power present
0147  *
0148  *   GPIO 0 -> enable output
0149  *   GPIO 1 -> route HP to front panel (0) or rear jack (1)
0150  *   GPIO 2 -> M0 of CS5381
0151  *   GPIO 3 -> M1 of CS5381
0152  *   GPIO 4 -> enable output
0153  *   GPIO 5 -> enable output
0154  *   GPIO 6 -> ?
0155  *   GPIO 7 -> route output to HP (0) or speaker (1)
0156  *   GPIO 8 -> route input jack to mic-in (0) or line-in (1)
0157  *
0158  * CM9780:
0159  *
0160  *   LINE_OUT -> input of ADC
0161  *
0162  *   AUX_IN   <- aux
0163  *   VIDEO_IN <- ?
0164  *   FMIC_IN  <- mic
0165  *
0166  *   GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
0167  *   GPO 1 -> route mic-in from input jack (0) or front panel header (1)
0168  */
0169 
0170 #include <linux/pci.h>
0171 #include <linux/delay.h>
0172 #include <linux/mutex.h>
0173 #include <sound/ac97_codec.h>
0174 #include <sound/control.h>
0175 #include <sound/core.h>
0176 #include <sound/info.h>
0177 #include <sound/pcm.h>
0178 #include <sound/pcm_params.h>
0179 #include <sound/tlv.h>
0180 #include "xonar.h"
0181 #include "cm9780.h"
0182 #include "pcm1796.h"
0183 #include "cs2000.h"
0184 
0185 
0186 #define GPIO_D2X_EXT_POWER  0x0020
0187 #define GPIO_D2_ALT     0x0080
0188 #define GPIO_D2_OUTPUT_ENABLE   0x0100
0189 
0190 #define GPI_EXT_POWER       0x01
0191 #define GPIO_INPUT_ROUTE    0x0100
0192 
0193 #define GPIO_HDAV_OUTPUT_ENABLE 0x0001
0194 #define GPIO_HDAV_MAGIC     0x00c0
0195 
0196 #define GPIO_DB_MASK        0x0030
0197 #define GPIO_DB_H6      0x0000
0198 
0199 #define GPIO_ST_OUTPUT_ENABLE   0x0001
0200 #define GPIO_ST_HP_REAR     0x0002
0201 #define GPIO_ST_MAGIC       0x0040
0202 #define GPIO_ST_HP      0x0080
0203 
0204 #define GPIO_XENSE_OUTPUT_ENABLE    (0x0001 | 0x0010 | 0x0020)
0205 #define GPIO_XENSE_SPEAKERS     0x0080
0206 
0207 #define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1)) /* 10011, ii, /W=0 */
0208 #define I2C_DEVICE_CS2000   0x9c            /* 100111, 0, /W=0 */
0209 
0210 #define PCM1796_REG_BASE    16
0211 
0212 
0213 struct xonar_pcm179x {
0214     struct xonar_generic generic;
0215     unsigned int dacs;
0216     u8 pcm1796_regs[4][5];
0217     unsigned int current_rate;
0218     bool h6;
0219     bool hp_active;
0220     s8 hp_gain_offset;
0221     bool has_cs2000;
0222     u8 cs2000_regs[0x1f];
0223     bool broken_i2c;
0224 };
0225 
0226 struct xonar_hdav {
0227     struct xonar_pcm179x pcm179x;
0228     struct xonar_hdmi hdmi;
0229 };
0230 
0231 
0232 static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
0233                      u8 reg, u8 value)
0234 {
0235     /* maps ALSA channel pair number to SPI output */
0236     static const u8 codec_map[4] = {
0237         0, 1, 2, 4
0238     };
0239     oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
0240              OXYGEN_SPI_DATA_LENGTH_2 |
0241              OXYGEN_SPI_CLOCK_160 |
0242              (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
0243              OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
0244              (reg << 8) | value);
0245 }
0246 
0247 static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
0248                      u8 reg, u8 value)
0249 {
0250     oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
0251 }
0252 
0253 static void pcm1796_write(struct oxygen *chip, unsigned int codec,
0254               u8 reg, u8 value)
0255 {
0256     struct xonar_pcm179x *data = chip->model_data;
0257 
0258     if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
0259         OXYGEN_FUNCTION_SPI)
0260         pcm1796_write_spi(chip, codec, reg, value);
0261     else
0262         pcm1796_write_i2c(chip, codec, reg, value);
0263     if ((unsigned int)(reg - PCM1796_REG_BASE)
0264         < ARRAY_SIZE(data->pcm1796_regs[codec]))
0265         data->pcm1796_regs[codec][reg - PCM1796_REG_BASE] = value;
0266 }
0267 
0268 static void pcm1796_write_cached(struct oxygen *chip, unsigned int codec,
0269                  u8 reg, u8 value)
0270 {
0271     struct xonar_pcm179x *data = chip->model_data;
0272 
0273     if (value != data->pcm1796_regs[codec][reg - PCM1796_REG_BASE])
0274         pcm1796_write(chip, codec, reg, value);
0275 }
0276 
0277 static void cs2000_write(struct oxygen *chip, u8 reg, u8 value)
0278 {
0279     struct xonar_pcm179x *data = chip->model_data;
0280 
0281     oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value);
0282     data->cs2000_regs[reg] = value;
0283 }
0284 
0285 static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value)
0286 {
0287     struct xonar_pcm179x *data = chip->model_data;
0288 
0289     if (value != data->cs2000_regs[reg])
0290         cs2000_write(chip, reg, value);
0291 }
0292 
0293 static void pcm1796_registers_init(struct oxygen *chip)
0294 {
0295     struct xonar_pcm179x *data = chip->model_data;
0296     unsigned int i;
0297     s8 gain_offset;
0298 
0299     msleep(1);
0300     gain_offset = data->hp_active ? data->hp_gain_offset : 0;
0301     for (i = 0; i < data->dacs; ++i) {
0302         /* set ATLD before ATL/ATR */
0303         pcm1796_write(chip, i, 18,
0304                   data->pcm1796_regs[0][18 - PCM1796_REG_BASE]);
0305         pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]
0306                   + gain_offset);
0307         pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]
0308                   + gain_offset);
0309         pcm1796_write(chip, i, 19,
0310                   data->pcm1796_regs[0][19 - PCM1796_REG_BASE]);
0311         pcm1796_write(chip, i, 20,
0312                   data->pcm1796_regs[0][20 - PCM1796_REG_BASE]);
0313         pcm1796_write(chip, i, 21, 0);
0314         gain_offset = 0;
0315     }
0316 }
0317 
0318 static void pcm1796_init(struct oxygen *chip)
0319 {
0320     struct xonar_pcm179x *data = chip->model_data;
0321 
0322     data->pcm1796_regs[0][18 - PCM1796_REG_BASE] =
0323         PCM1796_FMT_24_I2S | PCM1796_ATLD;
0324     if (!data->broken_i2c)
0325         data->pcm1796_regs[0][18 - PCM1796_REG_BASE] |= PCM1796_MUTE;
0326     data->pcm1796_regs[0][19 - PCM1796_REG_BASE] =
0327         PCM1796_FLT_SHARP | PCM1796_ATS_1;
0328     data->pcm1796_regs[0][20 - PCM1796_REG_BASE] =
0329         data->h6 ? PCM1796_OS_64 : PCM1796_OS_128;
0330     pcm1796_registers_init(chip);
0331     data->current_rate = 48000;
0332 }
0333 
0334 static void xonar_d2_init(struct oxygen *chip)
0335 {
0336     struct xonar_pcm179x *data = chip->model_data;
0337 
0338     data->generic.anti_pop_delay = 300;
0339     data->generic.output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
0340     data->dacs = 4;
0341 
0342     pcm1796_init(chip);
0343 
0344     oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
0345     oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);
0346 
0347     oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
0348 
0349     xonar_init_cs53x1(chip);
0350     xonar_enable_output(chip);
0351 
0352     snd_component_add(chip->card, "PCM1796");
0353     snd_component_add(chip->card, "CS5381");
0354 }
0355 
0356 static void xonar_d2x_init(struct oxygen *chip)
0357 {
0358     struct xonar_pcm179x *data = chip->model_data;
0359 
0360     data->generic.ext_power_reg = OXYGEN_GPIO_DATA;
0361     data->generic.ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
0362     data->generic.ext_power_bit = GPIO_D2X_EXT_POWER;
0363     oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
0364     xonar_init_ext_power(chip);
0365     xonar_d2_init(chip);
0366 }
0367 
0368 static void xonar_hdav_init(struct oxygen *chip)
0369 {
0370     struct xonar_hdav *data = chip->model_data;
0371 
0372     oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
0373                OXYGEN_2WIRE_LENGTH_8 |
0374                OXYGEN_2WIRE_INTERRUPT_MASK |
0375                OXYGEN_2WIRE_SPEED_STANDARD);
0376 
0377     data->pcm179x.generic.anti_pop_delay = 100;
0378     data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE;
0379     data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA;
0380     data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
0381     data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER;
0382     data->pcm179x.dacs = chip->model.dac_channels_mixer / 2;
0383     data->pcm179x.h6 = chip->model.dac_channels_mixer > 2;
0384 
0385     pcm1796_init(chip);
0386 
0387     oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
0388               GPIO_HDAV_MAGIC | GPIO_INPUT_ROUTE);
0389     oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE);
0390 
0391     xonar_init_cs53x1(chip);
0392     xonar_init_ext_power(chip);
0393     xonar_hdmi_init(chip, &data->hdmi);
0394     xonar_enable_output(chip);
0395 
0396     snd_component_add(chip->card, "PCM1796");
0397     snd_component_add(chip->card, "CS5381");
0398 }
0399 
0400 static void xonar_st_init_i2c(struct oxygen *chip)
0401 {
0402     oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
0403                OXYGEN_2WIRE_LENGTH_8 |
0404                OXYGEN_2WIRE_INTERRUPT_MASK |
0405                OXYGEN_2WIRE_SPEED_STANDARD);
0406 }
0407 
0408 static void xonar_st_init_common(struct oxygen *chip)
0409 {
0410     struct xonar_pcm179x *data = chip->model_data;
0411 
0412     data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
0413     data->dacs = chip->model.dac_channels_mixer / 2;
0414     data->h6 = chip->model.dac_channels_mixer > 2;
0415     data->hp_gain_offset = 2*-18;
0416 
0417     pcm1796_init(chip);
0418 
0419     oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
0420               GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR |
0421               GPIO_ST_MAGIC | GPIO_ST_HP);
0422     oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
0423                 GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
0424 
0425     xonar_init_cs53x1(chip);
0426     xonar_enable_output(chip);
0427 
0428     snd_component_add(chip->card, "PCM1792A");
0429     snd_component_add(chip->card, "CS5381");
0430 }
0431 
0432 static void cs2000_registers_init(struct oxygen *chip)
0433 {
0434     struct xonar_pcm179x *data = chip->model_data;
0435 
0436     cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
0437     cs2000_write(chip, CS2000_DEV_CTRL, 0);
0438     cs2000_write(chip, CS2000_DEV_CFG_1,
0439              CS2000_R_MOD_SEL_1 |
0440              (0 << CS2000_R_SEL_SHIFT) |
0441              CS2000_AUX_OUT_SRC_REF_CLK |
0442              CS2000_EN_DEV_CFG_1);
0443     cs2000_write(chip, CS2000_DEV_CFG_2,
0444              (0 << CS2000_LOCK_CLK_SHIFT) |
0445              CS2000_FRAC_N_SRC_STATIC);
0446     cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
0447     cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
0448     cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
0449     cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
0450     cs2000_write(chip, CS2000_FUN_CFG_1,
0451              data->cs2000_regs[CS2000_FUN_CFG_1]);
0452     cs2000_write(chip, CS2000_FUN_CFG_2, 0);
0453     cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
0454     msleep(3); /* PLL lock delay */
0455 }
0456 
0457 static void xonar_st_init(struct oxygen *chip)
0458 {
0459     struct xonar_pcm179x *data = chip->model_data;
0460 
0461     data->generic.anti_pop_delay = 100;
0462     data->h6 = chip->model.dac_channels_mixer > 2;
0463     data->has_cs2000 = true;
0464     data->cs2000_regs[CS2000_FUN_CFG_1] = CS2000_REF_CLK_DIV_1;
0465     data->broken_i2c = true;
0466 
0467     oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
0468                OXYGEN_RATE_48000 |
0469                OXYGEN_I2S_FORMAT_I2S |
0470                OXYGEN_I2S_MCLK(data->h6 ? MCLK_256 : MCLK_512) |
0471                OXYGEN_I2S_BITS_16 |
0472                OXYGEN_I2S_MASTER |
0473                OXYGEN_I2S_BCLK_64);
0474 
0475     xonar_st_init_i2c(chip);
0476     cs2000_registers_init(chip);
0477     xonar_st_init_common(chip);
0478 
0479     snd_component_add(chip->card, "CS2000");
0480 }
0481 
0482 static void xonar_stx_init(struct oxygen *chip)
0483 {
0484     struct xonar_pcm179x *data = chip->model_data;
0485 
0486     xonar_st_init_i2c(chip);
0487     data->generic.anti_pop_delay = 800;
0488     data->generic.ext_power_reg = OXYGEN_GPI_DATA;
0489     data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
0490     data->generic.ext_power_bit = GPI_EXT_POWER;
0491     xonar_init_ext_power(chip);
0492     xonar_st_init_common(chip);
0493 }
0494 
0495 static void xonar_xense_init(struct oxygen *chip)
0496 {
0497     struct xonar_pcm179x *data = chip->model_data;
0498 
0499     data->generic.ext_power_reg = OXYGEN_GPI_DATA;
0500     data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
0501     data->generic.ext_power_bit = GPI_EXT_POWER;
0502     xonar_init_ext_power(chip);
0503 
0504     data->generic.anti_pop_delay = 100;
0505     data->has_cs2000 = true;
0506     data->cs2000_regs[CS2000_FUN_CFG_1] = CS2000_REF_CLK_DIV_1;
0507 
0508     oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
0509         OXYGEN_RATE_48000 |
0510         OXYGEN_I2S_FORMAT_I2S |
0511         OXYGEN_I2S_MCLK(MCLK_512) |
0512         OXYGEN_I2S_BITS_16 |
0513         OXYGEN_I2S_MASTER |
0514         OXYGEN_I2S_BCLK_64);
0515 
0516     xonar_st_init_i2c(chip);
0517     cs2000_registers_init(chip);
0518 
0519     data->generic.output_enable_bit = GPIO_XENSE_OUTPUT_ENABLE;
0520     data->dacs = 1;
0521     data->hp_gain_offset = 2*-18;
0522 
0523     pcm1796_init(chip);
0524 
0525     oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
0526         GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR |
0527         GPIO_ST_MAGIC | GPIO_XENSE_SPEAKERS);
0528     oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
0529         GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR |
0530         GPIO_XENSE_SPEAKERS);
0531 
0532     xonar_init_cs53x1(chip);
0533     xonar_enable_output(chip);
0534 
0535     snd_component_add(chip->card, "PCM1796");
0536     snd_component_add(chip->card, "CS5381");
0537     snd_component_add(chip->card, "CS2000");
0538 }
0539 
0540 static void xonar_d2_cleanup(struct oxygen *chip)
0541 {
0542     xonar_disable_output(chip);
0543 }
0544 
0545 static void xonar_hdav_cleanup(struct oxygen *chip)
0546 {
0547     xonar_hdmi_cleanup(chip);
0548     xonar_disable_output(chip);
0549     msleep(2);
0550 }
0551 
0552 static void xonar_st_cleanup(struct oxygen *chip)
0553 {
0554     xonar_disable_output(chip);
0555 }
0556 
0557 static void xonar_d2_suspend(struct oxygen *chip)
0558 {
0559     xonar_d2_cleanup(chip);
0560 }
0561 
0562 static void xonar_hdav_suspend(struct oxygen *chip)
0563 {
0564     xonar_hdav_cleanup(chip);
0565 }
0566 
0567 static void xonar_st_suspend(struct oxygen *chip)
0568 {
0569     xonar_st_cleanup(chip);
0570 }
0571 
0572 static void xonar_d2_resume(struct oxygen *chip)
0573 {
0574     pcm1796_registers_init(chip);
0575     xonar_enable_output(chip);
0576 }
0577 
0578 static void xonar_hdav_resume(struct oxygen *chip)
0579 {
0580     struct xonar_hdav *data = chip->model_data;
0581 
0582     pcm1796_registers_init(chip);
0583     xonar_hdmi_resume(chip, &data->hdmi);
0584     xonar_enable_output(chip);
0585 }
0586 
0587 static void xonar_stx_resume(struct oxygen *chip)
0588 {
0589     pcm1796_registers_init(chip);
0590     xonar_enable_output(chip);
0591 }
0592 
0593 static void xonar_st_resume(struct oxygen *chip)
0594 {
0595     cs2000_registers_init(chip);
0596     xonar_stx_resume(chip);
0597 }
0598 
0599 static void update_pcm1796_oversampling(struct oxygen *chip)
0600 {
0601     struct xonar_pcm179x *data = chip->model_data;
0602     unsigned int i;
0603     u8 reg;
0604 
0605     if (data->current_rate <= 48000 && !data->h6)
0606         reg = PCM1796_OS_128;
0607     else
0608         reg = PCM1796_OS_64;
0609     for (i = 0; i < data->dacs; ++i)
0610         pcm1796_write_cached(chip, i, 20, reg);
0611 }
0612 
0613 static void update_pcm1796_deemph(struct oxygen *chip)
0614 {
0615     struct xonar_pcm179x *data = chip->model_data;
0616     unsigned int i;
0617     u8 reg;
0618 
0619     reg = data->pcm1796_regs[0][18 - PCM1796_REG_BASE] & ~PCM1796_DMF_MASK;
0620     if (data->current_rate == 48000)
0621         reg |= PCM1796_DMF_48;
0622     else if (data->current_rate == 44100)
0623         reg |= PCM1796_DMF_441;
0624     else if (data->current_rate == 32000)
0625         reg |= PCM1796_DMF_32;
0626     for (i = 0; i < data->dacs; ++i)
0627         pcm1796_write_cached(chip, i, 18, reg);
0628 }
0629 
0630 static void set_pcm1796_params(struct oxygen *chip,
0631                    struct snd_pcm_hw_params *params)
0632 {
0633     struct xonar_pcm179x *data = chip->model_data;
0634 
0635     msleep(1);
0636     data->current_rate = params_rate(params);
0637     update_pcm1796_oversampling(chip);
0638     update_pcm1796_deemph(chip);
0639 }
0640 
0641 static void update_pcm1796_volume(struct oxygen *chip)
0642 {
0643     struct xonar_pcm179x *data = chip->model_data;
0644     unsigned int i;
0645     s8 gain_offset;
0646 
0647     gain_offset = data->hp_active ? data->hp_gain_offset : 0;
0648     for (i = 0; i < data->dacs; ++i) {
0649         pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
0650                      + gain_offset);
0651         pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
0652                      + gain_offset);
0653         gain_offset = 0;
0654     }
0655 }
0656 
0657 static void update_pcm1796_mute(struct oxygen *chip)
0658 {
0659     struct xonar_pcm179x *data = chip->model_data;
0660     unsigned int i;
0661     u8 value;
0662 
0663     value = data->pcm1796_regs[0][18 - PCM1796_REG_BASE];
0664     if (chip->dac_mute)
0665         value |= PCM1796_MUTE;
0666     else
0667         value &= ~PCM1796_MUTE;
0668     for (i = 0; i < data->dacs; ++i)
0669         pcm1796_write_cached(chip, i, 18, value);
0670 }
0671 
0672 static void update_cs2000_rate(struct oxygen *chip, unsigned int rate)
0673 {
0674     struct xonar_pcm179x *data = chip->model_data;
0675     u8 rate_mclk, reg;
0676 
0677     switch (rate) {
0678     case 32000:
0679     case 64000:
0680         rate_mclk = OXYGEN_RATE_32000;
0681         break;
0682     case 44100:
0683     case 88200:
0684     case 176400:
0685         rate_mclk = OXYGEN_RATE_44100;
0686         break;
0687     default:
0688     case 48000:
0689     case 96000:
0690     case 192000:
0691         rate_mclk = OXYGEN_RATE_48000;
0692         break;
0693     }
0694 
0695     if (rate <= 96000 && (rate > 48000 || data->h6)) {
0696         rate_mclk |= OXYGEN_I2S_MCLK(MCLK_256);
0697         reg = CS2000_REF_CLK_DIV_1;
0698     } else {
0699         rate_mclk |= OXYGEN_I2S_MCLK(MCLK_512);
0700         reg = CS2000_REF_CLK_DIV_2;
0701     }
0702 
0703     oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
0704                   OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
0705     cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
0706     msleep(3); /* PLL lock delay */
0707 }
0708 
0709 static void set_st_params(struct oxygen *chip,
0710               struct snd_pcm_hw_params *params)
0711 {
0712     update_cs2000_rate(chip, params_rate(params));
0713     set_pcm1796_params(chip, params);
0714 }
0715 
0716 static void set_hdav_params(struct oxygen *chip,
0717                 struct snd_pcm_hw_params *params)
0718 {
0719     struct xonar_hdav *data = chip->model_data;
0720 
0721     set_pcm1796_params(chip, params);
0722     xonar_set_hdmi_params(chip, &data->hdmi, params);
0723 }
0724 
0725 static const struct snd_kcontrol_new alt_switch = {
0726     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0727     .name = "Analog Loopback Switch",
0728     .info = snd_ctl_boolean_mono_info,
0729     .get = xonar_gpio_bit_switch_get,
0730     .put = xonar_gpio_bit_switch_put,
0731     .private_value = GPIO_D2_ALT,
0732 };
0733 
0734 static int rolloff_info(struct snd_kcontrol *ctl,
0735             struct snd_ctl_elem_info *info)
0736 {
0737     static const char *const names[2] = {
0738         "Sharp Roll-off", "Slow Roll-off"
0739     };
0740 
0741     return snd_ctl_enum_info(info, 1, 2, names);
0742 }
0743 
0744 static int rolloff_get(struct snd_kcontrol *ctl,
0745                struct snd_ctl_elem_value *value)
0746 {
0747     struct oxygen *chip = ctl->private_data;
0748     struct xonar_pcm179x *data = chip->model_data;
0749 
0750     value->value.enumerated.item[0] =
0751         (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] &
0752          PCM1796_FLT_MASK) != PCM1796_FLT_SHARP;
0753     return 0;
0754 }
0755 
0756 static int rolloff_put(struct snd_kcontrol *ctl,
0757                struct snd_ctl_elem_value *value)
0758 {
0759     struct oxygen *chip = ctl->private_data;
0760     struct xonar_pcm179x *data = chip->model_data;
0761     unsigned int i;
0762     int changed;
0763     u8 reg;
0764 
0765     mutex_lock(&chip->mutex);
0766     reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
0767     reg &= ~PCM1796_FLT_MASK;
0768     if (!value->value.enumerated.item[0])
0769         reg |= PCM1796_FLT_SHARP;
0770     else
0771         reg |= PCM1796_FLT_SLOW;
0772     changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
0773     if (changed) {
0774         for (i = 0; i < data->dacs; ++i)
0775             pcm1796_write(chip, i, 19, reg);
0776     }
0777     mutex_unlock(&chip->mutex);
0778     return changed;
0779 }
0780 
0781 static const struct snd_kcontrol_new rolloff_control = {
0782     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0783     .name = "DAC Filter Playback Enum",
0784     .info = rolloff_info,
0785     .get = rolloff_get,
0786     .put = rolloff_put,
0787 };
0788 
0789 static int deemph_get(struct snd_kcontrol *ctl,
0790                struct snd_ctl_elem_value *value)
0791 {
0792     struct oxygen *chip = ctl->private_data;
0793     struct xonar_pcm179x *data = chip->model_data;
0794 
0795     value->value.integer.value[0] =
0796         !!(data->pcm1796_regs[0][18 - PCM1796_REG_BASE] & PCM1796_DME);
0797     return 0;
0798 }
0799 
0800 static int deemph_put(struct snd_kcontrol *ctl,
0801                struct snd_ctl_elem_value *value)
0802 {
0803     struct oxygen *chip = ctl->private_data;
0804     struct xonar_pcm179x *data = chip->model_data;
0805     unsigned int i;
0806     int changed;
0807     u8 reg;
0808 
0809     mutex_lock(&chip->mutex);
0810     reg = data->pcm1796_regs[0][18 - PCM1796_REG_BASE];
0811     if (!value->value.integer.value[0])
0812         reg &= ~PCM1796_DME;
0813     else
0814         reg |= PCM1796_DME;
0815     changed = reg != data->pcm1796_regs[0][18 - PCM1796_REG_BASE];
0816     if (changed) {
0817         for (i = 0; i < data->dacs; ++i)
0818             pcm1796_write(chip, i, 18, reg);
0819     }
0820     mutex_unlock(&chip->mutex);
0821     return changed;
0822 }
0823 
0824 static const struct snd_kcontrol_new deemph_control = {
0825     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0826     .name = "De-emphasis Playback Switch",
0827     .info = snd_ctl_boolean_mono_info,
0828     .get = deemph_get,
0829     .put = deemph_put,
0830 };
0831 
0832 static const struct snd_kcontrol_new hdav_hdmi_control = {
0833     .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0834     .name = "HDMI Playback Switch",
0835     .info = snd_ctl_boolean_mono_info,
0836     .get = xonar_gpio_bit_switch_get,
0837     .put = xonar_gpio_bit_switch_put,
0838     .private_value = GPIO_HDAV_OUTPUT_ENABLE | XONAR_GPIO_BIT_INVERT,
0839 };
0840 
0841 static int st_output_switch_info(struct snd_kcontrol *ctl,
0842                  struct snd_ctl_elem_info *info)
0843 {
0844     static const char *const names[3] = {
0845         "Speakers", "Headphones", "FP Headphones"
0846     };
0847 
0848     return snd_ctl_enum_info(info, 1, 3, names);
0849 }
0850 
0851 static int st_output_switch_get(struct snd_kcontrol *ctl,
0852                 struct snd_ctl_elem_value *value)
0853 {
0854     struct oxygen *chip = ctl->private_data;
0855     u16 gpio;
0856 
0857     gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
0858     if (!(gpio & GPIO_ST_HP))
0859         value->value.enumerated.item[0] = 0;
0860     else if (gpio & GPIO_ST_HP_REAR)
0861         value->value.enumerated.item[0] = 1;
0862     else
0863         value->value.enumerated.item[0] = 2;
0864     return 0;
0865 }
0866 
0867 
0868 static int st_output_switch_put(struct snd_kcontrol *ctl,
0869                 struct snd_ctl_elem_value *value)
0870 {
0871     struct oxygen *chip = ctl->private_data;
0872     struct xonar_pcm179x *data = chip->model_data;
0873     u16 gpio_old, gpio;
0874 
0875     mutex_lock(&chip->mutex);
0876     gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
0877     gpio = gpio_old;
0878     switch (value->value.enumerated.item[0]) {
0879     case 0:
0880         gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
0881         break;
0882     case 1:
0883         gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
0884         break;
0885     case 2:
0886         gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
0887         break;
0888     }
0889     oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
0890     data->hp_active = gpio & GPIO_ST_HP;
0891     update_pcm1796_volume(chip);
0892     mutex_unlock(&chip->mutex);
0893     return gpio != gpio_old;
0894 }
0895 
0896 static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
0897                     struct snd_ctl_elem_info *info)
0898 {
0899     static const char *const names[4] = {
0900         "< 32 ohms", "32-64 ohms", "64-300 ohms", "300-600 ohms"
0901     };
0902 
0903     return snd_ctl_enum_info(info, 1, 4, names);
0904 }
0905 
0906 static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
0907                    struct snd_ctl_elem_value *value)
0908 {
0909     struct oxygen *chip = ctl->private_data;
0910     struct xonar_pcm179x *data = chip->model_data;
0911 
0912     mutex_lock(&chip->mutex);
0913     if (data->hp_gain_offset < 2*-12)
0914         value->value.enumerated.item[0] = 0;
0915     else if (data->hp_gain_offset < 2*-6)
0916         value->value.enumerated.item[0] = 1;
0917     else if (data->hp_gain_offset < 0)
0918         value->value.enumerated.item[0] = 2;
0919     else
0920         value->value.enumerated.item[0] = 3;
0921     mutex_unlock(&chip->mutex);
0922     return 0;
0923 }
0924 
0925 
0926 static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
0927                    struct snd_ctl_elem_value *value)
0928 {
0929     static const s8 offsets[] = { 2*-18, 2*-12, 2*-6, 0 };
0930     struct oxygen *chip = ctl->private_data;
0931     struct xonar_pcm179x *data = chip->model_data;
0932     s8 offset;
0933     int changed;
0934 
0935     if (value->value.enumerated.item[0] > 3)
0936         return -EINVAL;
0937     offset = offsets[value->value.enumerated.item[0]];
0938     mutex_lock(&chip->mutex);
0939     changed = offset != data->hp_gain_offset;
0940     if (changed) {
0941         data->hp_gain_offset = offset;
0942         update_pcm1796_volume(chip);
0943     }
0944     mutex_unlock(&chip->mutex);
0945     return changed;
0946 }
0947 
0948 static const struct snd_kcontrol_new st_controls[] = {
0949     {
0950         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0951         .name = "Analog Output",
0952         .info = st_output_switch_info,
0953         .get = st_output_switch_get,
0954         .put = st_output_switch_put,
0955     },
0956     {
0957         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
0958         .name = "Headphones Impedance Playback Enum",
0959         .info = st_hp_volume_offset_info,
0960         .get = st_hp_volume_offset_get,
0961         .put = st_hp_volume_offset_put,
0962     },
0963 };
0964 
0965 static int xense_output_switch_get(struct snd_kcontrol *ctl,
0966                    struct snd_ctl_elem_value *value)
0967 {
0968     struct oxygen *chip = ctl->private_data;
0969     u16 gpio;
0970 
0971     gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
0972     if (gpio & GPIO_XENSE_SPEAKERS)
0973         value->value.enumerated.item[0] = 0;
0974     else if (!(gpio & GPIO_XENSE_SPEAKERS) && (gpio & GPIO_ST_HP_REAR))
0975         value->value.enumerated.item[0] = 1;
0976     else
0977         value->value.enumerated.item[0] = 2;
0978     return 0;
0979 }
0980 
0981 static int xense_output_switch_put(struct snd_kcontrol *ctl,
0982                    struct snd_ctl_elem_value *value)
0983 {
0984     struct oxygen *chip = ctl->private_data;
0985     struct xonar_pcm179x *data = chip->model_data;
0986     u16 gpio_old, gpio;
0987 
0988     mutex_lock(&chip->mutex);
0989     gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
0990     gpio = gpio_old;
0991     switch (value->value.enumerated.item[0]) {
0992     case 0:
0993         gpio |= GPIO_XENSE_SPEAKERS | GPIO_ST_HP_REAR;
0994         break;
0995     case 1:
0996         gpio = (gpio | GPIO_ST_HP_REAR) & ~GPIO_XENSE_SPEAKERS;
0997         break;
0998     case 2:
0999         gpio &= ~(GPIO_XENSE_SPEAKERS | GPIO_ST_HP_REAR);
1000         break;
1001     }
1002     oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
1003     data->hp_active = !(gpio & GPIO_XENSE_SPEAKERS);
1004     update_pcm1796_volume(chip);
1005     mutex_unlock(&chip->mutex);
1006     return gpio != gpio_old;
1007 }
1008 
1009 static const struct snd_kcontrol_new xense_controls[] = {
1010     {
1011         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1012         .name = "Analog Output",
1013         .info = st_output_switch_info,
1014         .get = xense_output_switch_get,
1015         .put = xense_output_switch_put,
1016     },
1017     {
1018         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1019         .name = "Headphones Impedance Playback Enum",
1020         .info = st_hp_volume_offset_info,
1021         .get = st_hp_volume_offset_get,
1022         .put = st_hp_volume_offset_put,
1023     },
1024 };
1025 
1026 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
1027                        unsigned int reg, unsigned int mute)
1028 {
1029     if (reg == AC97_LINE) {
1030         spin_lock_irq(&chip->reg_lock);
1031         oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
1032                       mute ? GPIO_INPUT_ROUTE : 0,
1033                       GPIO_INPUT_ROUTE);
1034         spin_unlock_irq(&chip->reg_lock);
1035     }
1036 }
1037 
1038 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
1039 
1040 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
1041 {
1042     if (!strncmp(template->name, "CD Capture ", 11))
1043         /* CD in is actually connected to the video in pin */
1044         template->private_value ^= AC97_CD ^ AC97_VIDEO;
1045     return 0;
1046 }
1047 
1048 static int xonar_st_h6_control_filter(struct snd_kcontrol_new *template)
1049 {
1050     if (!strncmp(template->name, "Master Playback ", 16))
1051         /* no volume/mute, as I²C to the third DAC does not work */
1052         return 1;
1053     return 0;
1054 }
1055 
1056 static int add_pcm1796_controls(struct oxygen *chip)
1057 {
1058     struct xonar_pcm179x *data = chip->model_data;
1059     int err;
1060 
1061     if (!data->broken_i2c) {
1062         err = snd_ctl_add(chip->card,
1063                   snd_ctl_new1(&rolloff_control, chip));
1064         if (err < 0)
1065             return err;
1066         err = snd_ctl_add(chip->card,
1067                   snd_ctl_new1(&deemph_control, chip));
1068         if (err < 0)
1069             return err;
1070     }
1071     return 0;
1072 }
1073 
1074 static int xonar_d2_mixer_init(struct oxygen *chip)
1075 {
1076     int err;
1077 
1078     err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
1079     if (err < 0)
1080         return err;
1081     err = add_pcm1796_controls(chip);
1082     if (err < 0)
1083         return err;
1084     return 0;
1085 }
1086 
1087 static int xonar_hdav_mixer_init(struct oxygen *chip)
1088 {
1089     int err;
1090 
1091     err = snd_ctl_add(chip->card, snd_ctl_new1(&hdav_hdmi_control, chip));
1092     if (err < 0)
1093         return err;
1094     err = add_pcm1796_controls(chip);
1095     if (err < 0)
1096         return err;
1097     return 0;
1098 }
1099 
1100 static int xonar_st_mixer_init(struct oxygen *chip)
1101 {
1102     unsigned int i;
1103     int err;
1104 
1105     for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
1106         err = snd_ctl_add(chip->card,
1107                   snd_ctl_new1(&st_controls[i], chip));
1108         if (err < 0)
1109             return err;
1110     }
1111     err = add_pcm1796_controls(chip);
1112     if (err < 0)
1113         return err;
1114     return 0;
1115 }
1116 
1117 static int xonar_xense_mixer_init(struct oxygen *chip)
1118 {
1119     unsigned int i;
1120     int err;
1121 
1122     for (i = 0; i < ARRAY_SIZE(xense_controls); ++i) {
1123         err = snd_ctl_add(chip->card,
1124         snd_ctl_new1(&xense_controls[i], chip));
1125         if (err < 0)
1126             return err;
1127     }
1128     err = add_pcm1796_controls(chip);
1129     if (err < 0)
1130         return err;
1131     return 0;
1132 }
1133 
1134 static void dump_pcm1796_registers(struct oxygen *chip,
1135                    struct snd_info_buffer *buffer)
1136 {
1137     struct xonar_pcm179x *data = chip->model_data;
1138     unsigned int dac, i;
1139 
1140     for (dac = 0; dac < data->dacs; ++dac) {
1141         snd_iprintf(buffer, "\nPCM1796 %u:", dac + 1);
1142         for (i = 0; i < 5; ++i)
1143             snd_iprintf(buffer, " %02x",
1144                     data->pcm1796_regs[dac][i]);
1145     }
1146     snd_iprintf(buffer, "\n");
1147 }
1148 
1149 static void dump_cs2000_registers(struct oxygen *chip,
1150                   struct snd_info_buffer *buffer)
1151 {
1152     struct xonar_pcm179x *data = chip->model_data;
1153     unsigned int i;
1154 
1155     if (data->has_cs2000) {
1156         snd_iprintf(buffer, "\nCS2000:\n00:   ");
1157         for (i = 1; i < 0x10; ++i)
1158             snd_iprintf(buffer, " %02x", data->cs2000_regs[i]);
1159         snd_iprintf(buffer, "\n10:");
1160         for (i = 0x10; i < 0x1f; ++i)
1161             snd_iprintf(buffer, " %02x", data->cs2000_regs[i]);
1162         snd_iprintf(buffer, "\n");
1163     }
1164 }
1165 
1166 static void dump_st_registers(struct oxygen *chip,
1167                   struct snd_info_buffer *buffer)
1168 {
1169     dump_pcm1796_registers(chip, buffer);
1170     dump_cs2000_registers(chip, buffer);
1171 }
1172 
1173 static const struct oxygen_model model_xonar_d2 = {
1174     .longname = "Asus Virtuoso 200",
1175     .chip = "AV200",
1176     .init = xonar_d2_init,
1177     .control_filter = xonar_d2_control_filter,
1178     .mixer_init = xonar_d2_mixer_init,
1179     .cleanup = xonar_d2_cleanup,
1180     .suspend = xonar_d2_suspend,
1181     .resume = xonar_d2_resume,
1182     .set_dac_params = set_pcm1796_params,
1183     .set_adc_params = xonar_set_cs53x1_params,
1184     .update_dac_volume = update_pcm1796_volume,
1185     .update_dac_mute = update_pcm1796_mute,
1186     .dump_registers = dump_pcm1796_registers,
1187     .dac_tlv = pcm1796_db_scale,
1188     .model_data_size = sizeof(struct xonar_pcm179x),
1189     .device_config = PLAYBACK_0_TO_I2S |
1190              PLAYBACK_1_TO_SPDIF |
1191              CAPTURE_0_FROM_I2S_2 |
1192              CAPTURE_1_FROM_SPDIF |
1193              MIDI_OUTPUT |
1194              MIDI_INPUT |
1195              AC97_CD_INPUT,
1196     .dac_channels_pcm = 8,
1197     .dac_channels_mixer = 8,
1198     .dac_volume_min = 255 - 2*60,
1199     .dac_volume_max = 255,
1200     .misc_flags = OXYGEN_MISC_MIDI,
1201     .function_flags = OXYGEN_FUNCTION_SPI |
1202               OXYGEN_FUNCTION_ENABLE_SPI_4_5,
1203     .dac_mclks = OXYGEN_MCLKS(512, 128, 128),
1204     .adc_mclks = OXYGEN_MCLKS(256, 128, 128),
1205     .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
1206     .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1207 };
1208 
1209 static const struct oxygen_model model_xonar_hdav = {
1210     .longname = "Asus Virtuoso 200",
1211     .chip = "AV200",
1212     .init = xonar_hdav_init,
1213     .mixer_init = xonar_hdav_mixer_init,
1214     .cleanup = xonar_hdav_cleanup,
1215     .suspend = xonar_hdav_suspend,
1216     .resume = xonar_hdav_resume,
1217     .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
1218     .set_dac_params = set_hdav_params,
1219     .set_adc_params = xonar_set_cs53x1_params,
1220     .update_dac_volume = update_pcm1796_volume,
1221     .update_dac_mute = update_pcm1796_mute,
1222     .uart_input = xonar_hdmi_uart_input,
1223     .ac97_switch = xonar_line_mic_ac97_switch,
1224     .dump_registers = dump_pcm1796_registers,
1225     .dac_tlv = pcm1796_db_scale,
1226     .model_data_size = sizeof(struct xonar_hdav),
1227     .device_config = PLAYBACK_0_TO_I2S |
1228              PLAYBACK_1_TO_SPDIF |
1229              CAPTURE_0_FROM_I2S_2 |
1230              CAPTURE_1_FROM_SPDIF,
1231     .dac_channels_pcm = 8,
1232     .dac_channels_mixer = 2,
1233     .dac_volume_min = 255 - 2*60,
1234     .dac_volume_max = 255,
1235     .misc_flags = OXYGEN_MISC_MIDI,
1236     .function_flags = OXYGEN_FUNCTION_2WIRE,
1237     .dac_mclks = OXYGEN_MCLKS(512, 128, 128),
1238     .adc_mclks = OXYGEN_MCLKS(256, 128, 128),
1239     .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
1240     .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1241 };
1242 
1243 static const struct oxygen_model model_xonar_st = {
1244     .longname = "Asus Virtuoso 100",
1245     .chip = "AV200",
1246     .init = xonar_st_init,
1247     .mixer_init = xonar_st_mixer_init,
1248     .cleanup = xonar_st_cleanup,
1249     .suspend = xonar_st_suspend,
1250     .resume = xonar_st_resume,
1251     .set_dac_params = set_st_params,
1252     .set_adc_params = xonar_set_cs53x1_params,
1253     .update_dac_volume = update_pcm1796_volume,
1254     .update_dac_mute = update_pcm1796_mute,
1255     .ac97_switch = xonar_line_mic_ac97_switch,
1256     .dump_registers = dump_st_registers,
1257     .dac_tlv = pcm1796_db_scale,
1258     .model_data_size = sizeof(struct xonar_pcm179x),
1259     .device_config = PLAYBACK_0_TO_I2S |
1260              PLAYBACK_1_TO_SPDIF |
1261              CAPTURE_0_FROM_I2S_2 |
1262              CAPTURE_1_FROM_SPDIF |
1263              AC97_FMIC_SWITCH,
1264     .dac_channels_pcm = 2,
1265     .dac_channels_mixer = 2,
1266     .dac_volume_min = 255 - 2*60,
1267     .dac_volume_max = 255,
1268     .function_flags = OXYGEN_FUNCTION_2WIRE,
1269     .dac_mclks = OXYGEN_MCLKS(512, 128, 128),
1270     .adc_mclks = OXYGEN_MCLKS(256, 128, 128),
1271     .dac_i2s_format = OXYGEN_I2S_FORMAT_I2S,
1272     .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1273 };
1274 
1275 int get_xonar_pcm179x_model(struct oxygen *chip,
1276                 const struct pci_device_id *id)
1277 {
1278     switch (id->subdevice) {
1279     case 0x8269:
1280         chip->model = model_xonar_d2;
1281         chip->model.shortname = "Xonar D2";
1282         break;
1283     case 0x82b7:
1284         chip->model = model_xonar_d2;
1285         chip->model.shortname = "Xonar D2X";
1286         chip->model.init = xonar_d2x_init;
1287         break;
1288     case 0x8314:
1289         chip->model = model_xonar_hdav;
1290         oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1291         switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1292         default:
1293             chip->model.shortname = "Xonar HDAV1.3";
1294             break;
1295         case GPIO_DB_H6:
1296             chip->model.shortname = "Xonar HDAV1.3+H6";
1297             chip->model.dac_channels_mixer = 8;
1298             chip->model.dac_mclks = OXYGEN_MCLKS(256, 128, 128);
1299             break;
1300         }
1301         break;
1302     case 0x835d:
1303         chip->model = model_xonar_st;
1304         oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1305         switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1306         default:
1307             chip->model.shortname = "Xonar ST";
1308             break;
1309         case GPIO_DB_H6:
1310             chip->model.shortname = "Xonar ST+H6";
1311             chip->model.control_filter = xonar_st_h6_control_filter;
1312             chip->model.dac_channels_pcm = 8;
1313             chip->model.dac_channels_mixer = 8;
1314             chip->model.dac_volume_min = 255;
1315             chip->model.dac_mclks = OXYGEN_MCLKS(256, 128, 128);
1316             break;
1317         }
1318         break;
1319     case 0x835c:
1320         chip->model = model_xonar_st;
1321         chip->model.shortname = "Xonar STX";
1322         chip->model.init = xonar_stx_init;
1323         chip->model.resume = xonar_stx_resume;
1324         chip->model.set_dac_params = set_pcm1796_params;
1325         break;
1326     case 0x85f4:
1327         chip->model = model_xonar_st;
1328         oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1329         switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1330         default:
1331             chip->model.shortname = "Xonar STX II";
1332             break;
1333         case GPIO_DB_H6:
1334             chip->model.shortname = "Xonar STX II+H6";
1335             chip->model.dac_channels_pcm = 8;
1336             chip->model.dac_channels_mixer = 8;
1337             chip->model.dac_mclks = OXYGEN_MCLKS(256, 128, 128);
1338             break;
1339         }
1340         chip->model.init = xonar_stx_init;
1341         chip->model.resume = xonar_stx_resume;
1342         chip->model.set_dac_params = set_pcm1796_params;
1343         break;
1344     case 0x8428:
1345         chip->model = model_xonar_st;
1346         chip->model.shortname = "Xonar Xense";
1347         chip->model.chip = "AV100";
1348         chip->model.init = xonar_xense_init;
1349         chip->model.mixer_init = xonar_xense_mixer_init;
1350         break;
1351     default:
1352         return -EINVAL;
1353     }
1354     return 0;
1355 }
[ 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!