sound/pci/oxygen/xonar_pcm179x.c

   1 /*
   2  * card driver for models with PCM1796 DACs (Xonar D2/D2X/HDAV1.3/ST/STX)
   3  *
   4  * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
   5  *
   6  *
   7  *  This driver is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License, version 2.
   9  *
  10  *  This driver is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this driver; if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 /*
  20  * Xonar D2/D2X
  21  * ------------
  22  *
  23  * CMI8788:
  24  *
  25  * SPI 0 -> 1st PCM1796 (front)
  26  * SPI 1 -> 2nd PCM1796 (surround)
  27  * SPI 2 -> 3rd PCM1796 (center/LFE)
  28  * SPI 4 -> 4th PCM1796 (back)
  29  *
  30  * GPIO 2 -> M0 of CS5381
  31  * GPIO 3 -> M1 of CS5381
  32  * GPIO 5 <- external power present (D2X only)
  33  * GPIO 7 -> ALT
  34  * GPIO 8 -> enable output to speakers
  35  *
  36  * CM9780:
  37  *
  38  * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
  39  */
  40
  41 /*
  42  * Xonar HDAV1.3 (Deluxe)
  43  * ----------------------
  44  *
  45  * CMI8788:
  46  *
  47  * I²C <-> PCM1796 (front)
  48  *
  49  * GPI 0 <- external power present
  50  *
  51  * GPIO 0 -> enable output to speakers
  52  * GPIO 2 -> M0 of CS5381
  53  * GPIO 3 -> M1 of CS5381
  54  * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
  55  *
  56  * TXD -> HDMI controller
  57  * RXD <- HDMI controller
  58  *
  59  * PCM1796 front: AD1,0 <- 0,0
  60  *
  61  * CM9780:
  62  *
  63  * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
  64  *
  65  * no daughterboard
  66  * ----------------
  67  *
  68  * GPIO 4 <- 1
  69  *
  70  * H6 daughterboard
  71  * ----------------
  72  *
  73  * GPIO 4 <- 0
  74  * GPIO 5 <- 0
  75  *
  76  * I²C <-> PCM1796 (surround)
  77  *     <-> PCM1796 (center/LFE)
  78  *     <-> PCM1796 (back)
  79  *
  80  * PCM1796 surround:   AD1,0 <- 0,1
  81  * PCM1796 center/LFE: AD1,0 <- 1,0
  82  * PCM1796 back:       AD1,0 <- 1,1
  83  *
  84  * unknown daughterboard
  85  * ---------------------
  86  *
  87  * GPIO 4 <- 0
  88  * GPIO 5 <- 1
  89  *
  90  * I²C <-> CS4362A (surround, center/LFE, back)
  91  *
  92  * CS4362A: AD0 <- 0
  93  */
  94
  95 /*
  96  * Xonar Essence ST (Deluxe)/STX
  97  * -----------------------------
  98  *
  99  * CMI8788:
 100  *
 101  * I²C <-> PCM1792A
 102  *     <-> CS2000 (ST only)
 103  *
 104  * ADC1 MCLK -> REF_CLK of CS2000 (ST only)
 105  *
 106  * GPI 0 <- external power present (STX only)
 107  *
 108  * GPIO 0 -> enable output to speakers
 109  * GPIO 1 -> route HP to front panel (0) or rear jack (1)
 110  * GPIO 2 -> M0 of CS5381
 111  * GPIO 3 -> M1 of CS5381
 112  * GPIO 7 -> route output to speaker jacks (0) or HP (1)
 113  * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
 114  *
 115  * PCM1792A:
 116  *
 117  * AD1,0 <- 0,0
 118  * SCK <- CLK_OUT of CS2000 (ST only)
 119  *
 120  * CS2000:
 121  *
 122  * AD0 <- 0
 123  *
 124  * CM9780:
 125  *
 126  * GPO 0 -> route line-in (0) or AC97 output (1) to CS5381 input
 127  *
 128  * H6 daughterboard
 129  * ----------------
 130  *
 131  * GPIO 4 <- 0
 132  * GPIO 5 <- 0
 133  */
 134
 135 #include <linux/pci.h>
 136 #include <linux/delay.h>
 137 #include <linux/mutex.h>
 138 #include <sound/ac97_codec.h>
 139 #include <sound/control.h>
 140 #include <sound/core.h>
 141 #include <sound/pcm.h>
 142 #include <sound/pcm_params.h>
 143 #include <sound/tlv.h>
 144 #include "xonar.h"
 145 #include "cm9780.h"
 146 #include "pcm1796.h"
 147 #include "cs2000.h"
 148
 149
 150 #define GPIO_D2X_EXT_POWER      0x0020
 151 #define GPIO_D2_ALT             0x0080
 152 #define GPIO_D2_OUTPUT_ENABLE   0x0100
 153
 154 #define GPI_EXT_POWER           0x01
 155 #define GPIO_INPUT_ROUTE        0x0100
 156
 157 #define GPIO_HDAV_OUTPUT_ENABLE 0x0001
 158
 159 #define GPIO_DB_MASK            0x0030
 160 #define GPIO_DB_H6              0x0000
 161
 162 #define GPIO_ST_OUTPUT_ENABLE   0x0001
 163 #define GPIO_ST_HP_REAR         0x0002
 164 #define GPIO_ST_HP              0x0080
 165
 166 #define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1))     /* 10011, ii, /W=0 */
 167 #define I2C_DEVICE_CS2000       0x9c                    /* 100111, 0, /W=0 */
 168
 169 #define PCM1796_REG_BASE        16
 170
 171
 172 struct xonar_pcm179x {
 173         struct xonar_generic generic;
 174         unsigned int dacs;
 175         u8 pcm1796_regs[4][5];
 176         bool hp_active;
 177         s8 hp_gain_offset;
 178         u8 cs2000_fun_cfg_1;
 179 };
 180
 181 struct xonar_hdav {
 182         struct xonar_pcm179x pcm179x;
 183         struct xonar_hdmi hdmi;
 184 };
 185
 186
 187 static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
 188                                      u8 reg, u8 value)
 189 {
 190         /* maps ALSA channel pair number to SPI output */
 191         static const u8 codec_map[4] = {
 192                 0, 1, 2, 4
 193         };
 194         oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
 195                          OXYGEN_SPI_DATA_LENGTH_2 |
 196                          OXYGEN_SPI_CLOCK_160 |
 197                          (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
 198                          OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
 199                          (reg << 8) | value);
 200 }
 201
 202 static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
 203                                      u8 reg, u8 value)
 204 {
 205         oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
 206 }
 207
 208 static void pcm1796_write(struct oxygen *chip, unsigned int codec,
 209                           u8 reg, u8 value)
 210 {
 211         struct xonar_pcm179x *data = chip->model_data;
 212
 213         if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
 214             OXYGEN_FUNCTION_SPI)
 215                 pcm1796_write_spi(chip, codec, reg, value);
 216         else
 217                 pcm1796_write_i2c(chip, codec, reg, value);
 218         if ((unsigned int)(reg - PCM1796_REG_BASE)
 219             < ARRAY_SIZE(data->pcm1796_regs[codec]))
 220                 data->pcm1796_regs[codec][reg - PCM1796_REG_BASE] = value;
 221 }
 222
 223 static void pcm1796_write_cached(struct oxygen *chip, unsigned int codec,
 224                                  u8 reg, u8 value)
 225 {
 226         struct xonar_pcm179x *data = chip->model_data;
 227
 228         if (value != data->pcm1796_regs[codec][reg - PCM1796_REG_BASE])
 229                 pcm1796_write(chip, codec, reg, value);
 230 }
 231
 232 static void cs2000_write(struct oxygen *chip, u8 reg, u8 value)
 233 {
 234         struct xonar_pcm179x *data = chip->model_data;
 235
 236         oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value);
 237         if (reg == CS2000_FUN_CFG_1)
 238                 data->cs2000_fun_cfg_1 = value;
 239 }
 240
 241 static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value)
 242 {
 243         struct xonar_pcm179x *data = chip->model_data;
 244
 245         if (reg != CS2000_FUN_CFG_1 ||
 246             value != data->cs2000_fun_cfg_1)
 247                 cs2000_write(chip, reg, value);
 248 }
 249
 250 static void pcm1796_registers_init(struct oxygen *chip)
 251 {
 252         struct xonar_pcm179x *data = chip->model_data;
 253         unsigned int i;
 254         s8 gain_offset;
 255
 256         gain_offset = data->hp_active ? data->hp_gain_offset : 0;
 257         for (i = 0; i < data->dacs; ++i) {
 258                 /* set ATLD before ATL/ATR */
 259                 pcm1796_write(chip, i, 18,
 260                               data->pcm1796_regs[0][18 - PCM1796_REG_BASE]);
 261                 pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]
 262                               + gain_offset);
 263                 pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]
 264                               + gain_offset);
 265                 pcm1796_write(chip, i, 19, PCM1796_FLT_SHARP | PCM1796_ATS_1);
 266                 pcm1796_write(chip, i, 20,
 267                               data->pcm1796_regs[0][20 - PCM1796_REG_BASE]);
 268                 pcm1796_write(chip, i, 21, 0);
 269         }
 270 }
 271
 272 static void pcm1796_init(struct oxygen *chip)
 273 {
 274         struct xonar_pcm179x *data = chip->model_data;
 275
 276         data->pcm1796_regs[0][18 - PCM1796_REG_BASE] = PCM1796_MUTE |
 277                 PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 278         data->pcm1796_regs[0][20 - PCM1796_REG_BASE] = PCM1796_OS_64;
 279         pcm1796_registers_init(chip);
 280 }
 281
 282 static void xonar_d2_init(struct oxygen *chip)
 283 {
 284         struct xonar_pcm179x *data = chip->model_data;
 285
 286         data->generic.anti_pop_delay = 300;
 287         data->generic.output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
 288         data->dacs = 4;
 289
 290         pcm1796_init(chip);
 291
 292         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
 293         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);
 294
 295         oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
 296
 297         xonar_init_cs53x1(chip);
 298         xonar_enable_output(chip);
 299
 300         snd_component_add(chip->card, "PCM1796");
 301         snd_component_add(chip->card, "CS5381");
 302 }
 303
 304 static void xonar_d2x_init(struct oxygen *chip)
 305 {
 306         struct xonar_pcm179x *data = chip->model_data;
 307
 308         data->generic.ext_power_reg = OXYGEN_GPIO_DATA;
 309         data->generic.ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
 310         data->generic.ext_power_bit = GPIO_D2X_EXT_POWER;
 311         oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
 312         xonar_init_ext_power(chip);
 313         xonar_d2_init(chip);
 314 }
 315
 316 static void xonar_hdav_init(struct oxygen *chip)
 317 {
 318         struct xonar_hdav *data = chip->model_data;
 319
 320         oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
 321                        OXYGEN_2WIRE_LENGTH_8 |
 322                        OXYGEN_2WIRE_INTERRUPT_MASK |
 323                        OXYGEN_2WIRE_SPEED_FAST);
 324
 325         data->pcm179x.generic.anti_pop_delay = 100;
 326         data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE;
 327         data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA;
 328         data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
 329         data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER;
 330         data->pcm179x.dacs = chip->model.private_data ? 4 : 1;
 331
 332         pcm1796_init(chip);
 333
 334         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_INPUT_ROUTE);
 335         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE);
 336
 337         xonar_init_cs53x1(chip);
 338         xonar_init_ext_power(chip);
 339         xonar_hdmi_init(chip, &data->hdmi);
 340         xonar_enable_output(chip);
 341
 342         snd_component_add(chip->card, "PCM1796");
 343         snd_component_add(chip->card, "CS5381");
 344 }
 345
 346 static void xonar_st_init_i2c(struct oxygen *chip)
 347 {
 348         oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
 349                        OXYGEN_2WIRE_LENGTH_8 |
 350                        OXYGEN_2WIRE_INTERRUPT_MASK |
 351                        OXYGEN_2WIRE_SPEED_FAST);
 352 }
 353
 354 static void xonar_st_init_common(struct oxygen *chip)
 355 {
 356         struct xonar_pcm179x *data = chip->model_data;
 357
 358         data->generic.anti_pop_delay = 100;
 359         data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
 360         data->dacs = chip->model.private_data ? 4 : 1;
 361         data->hp_gain_offset = 2*-18;
 362
 363         pcm1796_init(chip);
 364
 365         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
 366                           GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 367         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
 368                             GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 369
 370         xonar_init_cs53x1(chip);
 371         xonar_enable_output(chip);
 372
 373         snd_component_add(chip->card, "PCM1792A");
 374         snd_component_add(chip->card, "CS5381");
 375 }
 376
 377 static void cs2000_registers_init(struct oxygen *chip)
 378 {
 379         struct xonar_pcm179x *data = chip->model_data;
 380
 381         cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
 382         cs2000_write(chip, CS2000_DEV_CTRL, 0);
 383         cs2000_write(chip, CS2000_DEV_CFG_1,
 384                      CS2000_R_MOD_SEL_1 |
 385                      (0 << CS2000_R_SEL_SHIFT) |
 386                      CS2000_AUX_OUT_SRC_REF_CLK |
 387                      CS2000_EN_DEV_CFG_1);
 388         cs2000_write(chip, CS2000_DEV_CFG_2,
 389                      (0 << CS2000_LOCK_CLK_SHIFT) |
 390                      CS2000_FRAC_N_SRC_STATIC);
 391         cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
 392         cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
 393         cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
 394         cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
 395         cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
 396         cs2000_write(chip, CS2000_FUN_CFG_2, 0);
 397         cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
 398 }
 399
 400 static void xonar_st_init(struct oxygen *chip)
 401 {
 402         struct xonar_pcm179x *data = chip->model_data;
 403
 404         data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1;
 405
 406         oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
 407                        OXYGEN_RATE_48000 | OXYGEN_I2S_FORMAT_I2S |
 408                        OXYGEN_I2S_MCLK_128 | OXYGEN_I2S_BITS_16 |
 409                        OXYGEN_I2S_MASTER | OXYGEN_I2S_BCLK_64);
 410
 411         xonar_st_init_i2c(chip);
 412         cs2000_registers_init(chip);
 413         xonar_st_init_common(chip);
 414
 415         snd_component_add(chip->card, "CS2000");
 416 }
 417
 418 static void xonar_stx_init(struct oxygen *chip)
 419 {
 420         struct xonar_pcm179x *data = chip->model_data;
 421
 422         xonar_st_init_i2c(chip);
 423         data->generic.ext_power_reg = OXYGEN_GPI_DATA;
 424         data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
 425         data->generic.ext_power_bit = GPI_EXT_POWER;
 426         xonar_init_ext_power(chip);
 427         xonar_st_init_common(chip);
 428 }
 429
 430 static void xonar_d2_cleanup(struct oxygen *chip)
 431 {
 432         xonar_disable_output(chip);
 433 }
 434
 435 static void xonar_hdav_cleanup(struct oxygen *chip)
 436 {
 437         xonar_hdmi_cleanup(chip);
 438         xonar_disable_output(chip);
 439         msleep(2);
 440 }
 441
 442 static void xonar_st_cleanup(struct oxygen *chip)
 443 {
 444         xonar_disable_output(chip);
 445 }
 446
 447 static void xonar_d2_suspend(struct oxygen *chip)
 448 {
 449         xonar_d2_cleanup(chip);
 450 }
 451
 452 static void xonar_hdav_suspend(struct oxygen *chip)
 453 {
 454         xonar_hdav_cleanup(chip);
 455 }
 456
 457 static void xonar_st_suspend(struct oxygen *chip)
 458 {
 459         xonar_st_cleanup(chip);
 460 }
 461
 462 static void xonar_d2_resume(struct oxygen *chip)
 463 {
 464         pcm1796_registers_init(chip);
 465         xonar_enable_output(chip);
 466 }
 467
 468 static void xonar_hdav_resume(struct oxygen *chip)
 469 {
 470         struct xonar_hdav *data = chip->model_data;
 471
 472         pcm1796_registers_init(chip);
 473         xonar_hdmi_resume(chip, &data->hdmi);
 474         xonar_enable_output(chip);
 475 }
 476
 477 static void xonar_stx_resume(struct oxygen *chip)
 478 {
 479         pcm1796_registers_init(chip);
 480         xonar_enable_output(chip);
 481 }
 482
 483 static void xonar_st_resume(struct oxygen *chip)
 484 {
 485         cs2000_registers_init(chip);
 486         xonar_stx_resume(chip);
 487 }
 488
 489 static void set_pcm1796_params(struct oxygen *chip,
 490                                struct snd_pcm_hw_params *params)
 491 {
 492         struct xonar_pcm179x *data = chip->model_data;
 493         unsigned int i;
 494         u8 reg;
 495
 496         reg = params_rate(params) >= 96000 ? PCM1796_OS_32 : PCM1796_OS_64;
 497         for (i = 0; i < data->dacs; ++i)
 498                 pcm1796_write_cached(chip, i, 20, reg);
 499 }
 500
 501 static void update_pcm1796_volume(struct oxygen *chip)
 502 {
 503         struct xonar_pcm179x *data = chip->model_data;
 504         unsigned int i;
 505         s8 gain_offset;
 506
 507         gain_offset = data->hp_active ? data->hp_gain_offset : 0;
 508         for (i = 0; i < data->dacs; ++i) {
 509                 pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
 510                                      + gain_offset);
 511                 pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
 512                                      + gain_offset);
 513         }
 514 }
 515
 516 static void update_pcm1796_mute(struct oxygen *chip)
 517 {
 518         struct xonar_pcm179x *data = chip->model_data;
 519         unsigned int i;
 520         u8 value;
 521
 522         value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 523         if (chip->dac_mute)
 524                 value |= PCM1796_MUTE;
 525         for (i = 0; i < data->dacs; ++i)
 526                 pcm1796_write_cached(chip, i, 18, value);
 527 }
 528
 529 static void set_cs2000_params(struct oxygen *chip,
 530                               struct snd_pcm_hw_params *params)
 531 {
 532         /* XXX Why is the I2S A MCLK half the actual I2S multich MCLK? */
 533         static const u8 rate_mclks[] = {
 534                 [OXYGEN_RATE_32000] = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_128,
 535                 [OXYGEN_RATE_44100] = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128,
 536                 [OXYGEN_RATE_48000] = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128,
 537                 [OXYGEN_RATE_64000] = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256,
 538                 [OXYGEN_RATE_88200] = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256,
 539                 [OXYGEN_RATE_96000] = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256,
 540                 [OXYGEN_RATE_176400] = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256,
 541                 [OXYGEN_RATE_192000] = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256,
 542         };
 543         unsigned int rate_index;
 544         u8 rate_mclk, reg;
 545
 546         rate_index = oxygen_read16(chip, OXYGEN_I2S_MULTICH_FORMAT)
 547                 & OXYGEN_I2S_RATE_MASK;
 548         rate_mclk = rate_mclks[rate_index];
 549         oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
 550                               OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
 551         if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
 552                 reg = CS2000_REF_CLK_DIV_1;
 553         else
 554                 reg = CS2000_REF_CLK_DIV_2;
 555         cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
 556 }
 557
 558 static void set_st_params(struct oxygen *chip,
 559                           struct snd_pcm_hw_params *params)
 560 {
 561         set_cs2000_params(chip, params);
 562         set_pcm1796_params(chip, params);
 563 }
 564
 565 static void set_hdav_params(struct oxygen *chip,
 566                             struct snd_pcm_hw_params *params)
 567 {
 568         struct xonar_hdav *data = chip->model_data;
 569
 570         set_pcm1796_params(chip, params);
 571         xonar_set_hdmi_params(chip, &data->hdmi, params);
 572 }
 573
 574 static const struct snd_kcontrol_new alt_switch = {
 575         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 576         .name = "Analog Loopback Switch",
 577         .info = snd_ctl_boolean_mono_info,
 578         .get = xonar_gpio_bit_switch_get,
 579         .put = xonar_gpio_bit_switch_put,
 580         .private_value = GPIO_D2_ALT,
 581 };
 582
 583 static int st_output_switch_info(struct snd_kcontrol *ctl,
 584                                  struct snd_ctl_elem_info *info)
 585 {
 586         static const char *const names[3] = {
 587                 "Speakers", "Headphones", "FP Headphones"
 588         };
 589
 590         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 591         info->count = 1;
 592         info->value.enumerated.items = 3;
 593         if (info->value.enumerated.item >= 3)
 594                 info->value.enumerated.item = 2;
 595         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 596         return 0;
 597 }
 598
 599 static int st_output_switch_get(struct snd_kcontrol *ctl,
 600                                 struct snd_ctl_elem_value *value)
 601 {
 602         struct oxygen *chip = ctl->private_data;
 603         u16 gpio;
 604
 605         gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
 606         if (!(gpio & GPIO_ST_HP))
 607                 value->value.enumerated.item[0] = 0;
 608         else if (gpio & GPIO_ST_HP_REAR)
 609                 value->value.enumerated.item[0] = 1;
 610         else
 611                 value->value.enumerated.item[0] = 2;
 612         return 0;
 613 }
 614
 615
 616 static int st_output_switch_put(struct snd_kcontrol *ctl,
 617                                 struct snd_ctl_elem_value *value)
 618 {
 619         struct oxygen *chip = ctl->private_data;
 620         struct xonar_pcm179x *data = chip->model_data;
 621         u16 gpio_old, gpio;
 622
 623         mutex_lock(&chip->mutex);
 624         gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
 625         gpio = gpio_old;
 626         switch (value->value.enumerated.item[0]) {
 627         case 0:
 628                 gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
 629                 break;
 630         case 1:
 631                 gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
 632                 break;
 633         case 2:
 634                 gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
 635                 break;
 636         }
 637         oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
 638         data->hp_active = gpio & GPIO_ST_HP;
 639         update_pcm1796_volume(chip);
 640         mutex_unlock(&chip->mutex);
 641         return gpio != gpio_old;
 642 }
 643
 644 static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
 645                                     struct snd_ctl_elem_info *info)
 646 {
 647         static const char *const names[3] = {
 648                 "< 64 ohms", "64-300 ohms", "300-600 ohms"
 649         };
 650
 651         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 652         info->count = 1;
 653         info->value.enumerated.items = 3;
 654         if (info->value.enumerated.item > 2)
 655                 info->value.enumerated.item = 2;
 656         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 657         return 0;
 658 }
 659
 660 static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
 661                                    struct snd_ctl_elem_value *value)
 662 {
 663         struct oxygen *chip = ctl->private_data;
 664         struct xonar_pcm179x *data = chip->model_data;
 665
 666         mutex_lock(&chip->mutex);
 667         if (data->hp_gain_offset < 2*-6)
 668                 value->value.enumerated.item[0] = 0;
 669         else if (data->hp_gain_offset < 0)
 670                 value->value.enumerated.item[0] = 1;
 671         else
 672                 value->value.enumerated.item[0] = 2;
 673         mutex_unlock(&chip->mutex);
 674         return 0;
 675 }
 676
 677
 678 static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
 679                                    struct snd_ctl_elem_value *value)
 680 {
 681         static const s8 offsets[] = { 2*-18, 2*-6, 0 };
 682         struct oxygen *chip = ctl->private_data;
 683         struct xonar_pcm179x *data = chip->model_data;
 684         s8 offset;
 685         int changed;
 686
 687         if (value->value.enumerated.item[0] > 2)
 688                 return -EINVAL;
 689         offset = offsets[value->value.enumerated.item[0]];
 690         mutex_lock(&chip->mutex);
 691         changed = offset != data->hp_gain_offset;
 692         if (changed) {
 693                 data->hp_gain_offset = offset;
 694                 update_pcm1796_volume(chip);
 695         }
 696         mutex_unlock(&chip->mutex);
 697         return changed;
 698 }
 699
 700 static const struct snd_kcontrol_new st_controls[] = {
 701         {
 702                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 703                 .name = "Analog Output",
 704                 .info = st_output_switch_info,
 705                 .get = st_output_switch_get,
 706                 .put = st_output_switch_put,
 707         },
 708         {
 709                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 710                 .name = "Headphones Impedance Playback Enum",
 711                 .info = st_hp_volume_offset_info,
 712                 .get = st_hp_volume_offset_get,
 713                 .put = st_hp_volume_offset_put,
 714         },
 715 };
 716
 717 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
 718                                        unsigned int reg, unsigned int mute)
 719 {
 720         if (reg == AC97_LINE) {
 721                 spin_lock_irq(&chip->reg_lock);
 722                 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
 723                                       mute ? GPIO_INPUT_ROUTE : 0,
 724                                       GPIO_INPUT_ROUTE);
 725                 spin_unlock_irq(&chip->reg_lock);
 726         }
 727 }
 728
 729 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
 730
 731 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
 732 {
 733         if (!strncmp(template->name, "CD Capture ", 11))
 734                 /* CD in is actually connected to the video in pin */
 735                 template->private_value ^= AC97_CD ^ AC97_VIDEO;
 736         return 0;
 737 }
 738
 739 static int xonar_st_control_filter(struct snd_kcontrol_new *template)
 740 {
 741         if (!strncmp(template->name, "CD Capture ", 11))
 742                 return 1; /* no CD input */
 743         return 0;
 744 }
 745
 746 static int xonar_d2_mixer_init(struct oxygen *chip)
 747 {
 748         return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
 749 }
 750
 751 static int xonar_st_mixer_init(struct oxygen *chip)
 752 {
 753         unsigned int i;
 754         int err;
 755
 756         for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
 757                 err = snd_ctl_add(chip->card,
 758                                   snd_ctl_new1(&st_controls[i], chip));
 759                 if (err < 0)
 760                         return err;
 761         }
 762         return 0;
 763 }
 764
 765 static const struct oxygen_model model_xonar_d2 = {
 766         .longname = "Asus Virtuoso 200",
 767         .chip = "AV200",
 768         .init = xonar_d2_init,
 769         .control_filter = xonar_d2_control_filter,
 770         .mixer_init = xonar_d2_mixer_init,
 771         .cleanup = xonar_d2_cleanup,
 772         .suspend = xonar_d2_suspend,
 773         .resume = xonar_d2_resume,
 774         .get_i2s_mclk = oxygen_default_i2s_mclk,
 775         .set_dac_params = set_pcm1796_params,
 776         .set_adc_params = xonar_set_cs53x1_params,
 777         .update_dac_volume = update_pcm1796_volume,
 778         .update_dac_mute = update_pcm1796_mute,
 779         .dac_tlv = pcm1796_db_scale,
 780         .model_data_size = sizeof(struct xonar_pcm179x),
 781         .device_config = PLAYBACK_0_TO_I2S |
 782                          PLAYBACK_1_TO_SPDIF |
 783                          CAPTURE_0_FROM_I2S_2 |
 784                          CAPTURE_1_FROM_SPDIF |
 785                          MIDI_OUTPUT |
 786                          MIDI_INPUT,
 787         .dac_channels = 8,
 788         .dac_volume_min = 255 - 2*60,
 789         .dac_volume_max = 255,
 790         .misc_flags = OXYGEN_MISC_MIDI,
 791         .function_flags = OXYGEN_FUNCTION_SPI |
 792                           OXYGEN_FUNCTION_ENABLE_SPI_4_5,
 793         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 794         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 795 };
 796
 797 static const struct oxygen_model model_xonar_hdav = {
 798         .longname = "Asus Virtuoso 200",
 799         .chip = "AV200",
 800         .init = xonar_hdav_init,
 801         .cleanup = xonar_hdav_cleanup,
 802         .suspend = xonar_hdav_suspend,
 803         .resume = xonar_hdav_resume,
 804         .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
 805         .get_i2s_mclk = oxygen_default_i2s_mclk,
 806         .set_dac_params = set_hdav_params,
 807         .set_adc_params = xonar_set_cs53x1_params,
 808         .update_dac_volume = update_pcm1796_volume,
 809         .update_dac_mute = update_pcm1796_mute,
 810         .uart_input = xonar_hdmi_uart_input,
 811         .ac97_switch = xonar_line_mic_ac97_switch,
 812         .dac_tlv = pcm1796_db_scale,
 813         .model_data_size = sizeof(struct xonar_hdav),
 814         .device_config = PLAYBACK_0_TO_I2S |
 815                          PLAYBACK_1_TO_SPDIF |
 816                          CAPTURE_0_FROM_I2S_2 |
 817                          CAPTURE_1_FROM_SPDIF,
 818         .dac_channels = 8,
 819         .dac_volume_min = 255 - 2*60,
 820         .dac_volume_max = 255,
 821         .misc_flags = OXYGEN_MISC_MIDI,
 822         .function_flags = OXYGEN_FUNCTION_2WIRE,
 823         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 824         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 825 };
 826
 827 static const struct oxygen_model model_xonar_st = {
 828         .longname = "Asus Virtuoso 100",
 829         .chip = "AV200",
 830         .init = xonar_st_init,
 831         .control_filter = xonar_st_control_filter,
 832         .mixer_init = xonar_st_mixer_init,
 833         .cleanup = xonar_st_cleanup,
 834         .suspend = xonar_st_suspend,
 835         .resume = xonar_st_resume,
 836         .get_i2s_mclk = oxygen_default_i2s_mclk,
 837         .set_dac_params = set_st_params,
 838         .set_adc_params = xonar_set_cs53x1_params,
 839         .update_dac_volume = update_pcm1796_volume,
 840         .update_dac_mute = update_pcm1796_mute,
 841         .ac97_switch = xonar_line_mic_ac97_switch,
 842         .dac_tlv = pcm1796_db_scale,
 843         .model_data_size = sizeof(struct xonar_pcm179x),
 844         .device_config = PLAYBACK_0_TO_I2S |
 845                          PLAYBACK_1_TO_SPDIF |
 846                          CAPTURE_0_FROM_I2S_2,
 847         .dac_channels = 2,
 848         .dac_volume_min = 255 - 2*60,
 849         .dac_volume_max = 255,
 850         .function_flags = OXYGEN_FUNCTION_2WIRE,
 851         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 852         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
 853 };
 854
 855 int __devinit get_xonar_pcm179x_model(struct oxygen *chip,
 856                                       const struct pci_device_id *id)
 857 {
 858         switch (id->subdevice) {
 859         case 0x8269:
 860                 chip->model = model_xonar_d2;
 861                 chip->model.shortname = "Xonar D2";
 862                 break;
 863         case 0x82b7:
 864                 chip->model = model_xonar_d2;
 865                 chip->model.shortname = "Xonar D2X";
 866                 chip->model.init = xonar_d2x_init;
 867                 break;
 868         case 0x8314:
 869                 chip->model = model_xonar_hdav;
 870                 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
 871                 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
 872                 default:
 873                         chip->model.shortname = "Xonar HDAV1.3";
 874                         break;
 875                 case GPIO_DB_H6:
 876                         chip->model.shortname = "Xonar HDAV1.3+H6";
 877                         chip->model.private_data = 1;
 878                         break;
 879                 }
 880                 break;
 881         case 0x835d:
 882                 chip->model = model_xonar_st;
 883                 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
 884                 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
 885                 default:
 886                         chip->model.shortname = "Xonar ST";
 887                         break;
 888                 case GPIO_DB_H6:
 889                         chip->model.shortname = "Xonar ST+H6";
 890                         chip->model.dac_channels = 8;
 891                         chip->model.private_data = 1;
 892                         break;
 893                 }
 894                 break;
 895         case 0x835c:
 896                 chip->model = model_xonar_st;
 897                 chip->model.shortname = "Xonar STX";
 898                 chip->model.init = xonar_stx_init;
 899                 chip->model.resume = xonar_stx_resume;
 900                 chip->model.set_dac_params = set_pcm1796_params;
 901                 break;
 902         default:
 903                 return -EINVAL;
 904         }
 905         return 0;
 906 }