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 /*
 136  * Xonar HDAV1.3 Slim
 137  * ------------------
 138  *
 139  * CMI8788:
 140  *
 141  * GPIO 1 -> enable output
 142  *
 143  * TXD -> HDMI controller
 144  * RXD <- HDMI controller
 145  */
 146
 147 #include <linux/pci.h>
 148 #include <linux/delay.h>
 149 #include <linux/mutex.h>
 150 #include <sound/ac97_codec.h>
 151 #include <sound/control.h>
 152 #include <sound/core.h>
 153 #include <sound/pcm.h>
 154 #include <sound/pcm_params.h>
 155 #include <sound/tlv.h>
 156 #include "xonar.h"
 157 #include "cm9780.h"
 158 #include "pcm1796.h"
 159 #include "cs2000.h"
 160
 161
 162 #define GPIO_D2X_EXT_POWER      0x0020
 163 #define GPIO_D2_ALT             0x0080
 164 #define GPIO_D2_OUTPUT_ENABLE   0x0100
 165
 166 #define GPI_EXT_POWER           0x01
 167 #define GPIO_INPUT_ROUTE        0x0100
 168
 169 #define GPIO_HDAV_OUTPUT_ENABLE 0x0001
 170
 171 #define GPIO_DB_MASK            0x0030
 172 #define GPIO_DB_H6              0x0000
 173
 174 #define GPIO_ST_OUTPUT_ENABLE   0x0001
 175 #define GPIO_ST_HP_REAR         0x0002
 176 #define GPIO_ST_HP              0x0080
 177
 178 #define I2C_DEVICE_PCM1796(i)   (0x98 + ((i) << 1))     /* 10011, ii, /W=0 */
 179 #define I2C_DEVICE_CS2000       0x9c                    /* 100111, 0, /W=0 */
 180
 181 #define PCM1796_REG_BASE        16
 182
 183
 184 struct xonar_pcm179x {
 185         struct xonar_generic generic;
 186         unsigned int dacs;
 187         u8 pcm1796_regs[4][5];
 188         unsigned int current_rate;
 189         bool os_128;
 190         bool hp_active;
 191         s8 hp_gain_offset;
 192         bool has_cs2000;
 193         u8 cs2000_fun_cfg_1;
 194 };
 195
 196 struct xonar_hdav {
 197         struct xonar_pcm179x pcm179x;
 198         struct xonar_hdmi hdmi;
 199 };
 200
 201
 202 static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
 203                                      u8 reg, u8 value)
 204 {
 205         /* maps ALSA channel pair number to SPI output */
 206         static const u8 codec_map[4] = {
 207                 0, 1, 2, 4
 208         };
 209         oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
 210                          OXYGEN_SPI_DATA_LENGTH_2 |
 211                          OXYGEN_SPI_CLOCK_160 |
 212                          (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
 213                          OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
 214                          (reg << 8) | value);
 215 }
 216
 217 static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
 218                                      u8 reg, u8 value)
 219 {
 220         oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
 221 }
 222
 223 static void pcm1796_write(struct oxygen *chip, unsigned int codec,
 224                           u8 reg, u8 value)
 225 {
 226         struct xonar_pcm179x *data = chip->model_data;
 227
 228         if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
 229             OXYGEN_FUNCTION_SPI)
 230                 pcm1796_write_spi(chip, codec, reg, value);
 231         else
 232                 pcm1796_write_i2c(chip, codec, reg, value);
 233         if ((unsigned int)(reg - PCM1796_REG_BASE)
 234             < ARRAY_SIZE(data->pcm1796_regs[codec]))
 235                 data->pcm1796_regs[codec][reg - PCM1796_REG_BASE] = value;
 236 }
 237
 238 static void pcm1796_write_cached(struct oxygen *chip, unsigned int codec,
 239                                  u8 reg, u8 value)
 240 {
 241         struct xonar_pcm179x *data = chip->model_data;
 242
 243         if (value != data->pcm1796_regs[codec][reg - PCM1796_REG_BASE])
 244                 pcm1796_write(chip, codec, reg, value);
 245 }
 246
 247 static void cs2000_write(struct oxygen *chip, u8 reg, u8 value)
 248 {
 249         struct xonar_pcm179x *data = chip->model_data;
 250
 251         oxygen_write_i2c(chip, I2C_DEVICE_CS2000, reg, value);
 252         if (reg == CS2000_FUN_CFG_1)
 253                 data->cs2000_fun_cfg_1 = value;
 254 }
 255
 256 static void cs2000_write_cached(struct oxygen *chip, u8 reg, u8 value)
 257 {
 258         struct xonar_pcm179x *data = chip->model_data;
 259
 260         if (reg != CS2000_FUN_CFG_1 ||
 261             value != data->cs2000_fun_cfg_1)
 262                 cs2000_write(chip, reg, value);
 263 }
 264
 265 static void pcm1796_registers_init(struct oxygen *chip)
 266 {
 267         struct xonar_pcm179x *data = chip->model_data;
 268         unsigned int i;
 269         s8 gain_offset;
 270
 271         gain_offset = data->hp_active ? data->hp_gain_offset : 0;
 272         for (i = 0; i < data->dacs; ++i) {
 273                 /* set ATLD before ATL/ATR */
 274                 pcm1796_write(chip, i, 18,
 275                               data->pcm1796_regs[0][18 - PCM1796_REG_BASE]);
 276                 pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]
 277                               + gain_offset);
 278                 pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]
 279                               + gain_offset);
 280                 pcm1796_write(chip, i, 19,
 281                               data->pcm1796_regs[0][19 - PCM1796_REG_BASE]);
 282                 pcm1796_write(chip, i, 20,
 283                               data->pcm1796_regs[0][20 - PCM1796_REG_BASE]);
 284                 pcm1796_write(chip, i, 21, 0);
 285         }
 286 }
 287
 288 static void pcm1796_init(struct oxygen *chip)
 289 {
 290         struct xonar_pcm179x *data = chip->model_data;
 291
 292         data->pcm1796_regs[0][18 - PCM1796_REG_BASE] = PCM1796_MUTE |
 293                 PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 294         data->pcm1796_regs[0][19 - PCM1796_REG_BASE] =
 295                 PCM1796_FLT_SHARP | PCM1796_ATS_1;
 296         data->pcm1796_regs[0][20 - PCM1796_REG_BASE] = PCM1796_OS_64;
 297         pcm1796_registers_init(chip);
 298         data->current_rate = 48000;
 299 }
 300
 301 static void xonar_d2_init(struct oxygen *chip)
 302 {
 303         struct xonar_pcm179x *data = chip->model_data;
 304
 305         data->generic.anti_pop_delay = 300;
 306         data->generic.output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
 307         data->dacs = 4;
 308
 309         pcm1796_init(chip);
 310
 311         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
 312         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);
 313
 314         oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
 315
 316         xonar_init_cs53x1(chip);
 317         xonar_enable_output(chip);
 318
 319         snd_component_add(chip->card, "PCM1796");
 320         snd_component_add(chip->card, "CS5381");
 321 }
 322
 323 static void xonar_d2x_init(struct oxygen *chip)
 324 {
 325         struct xonar_pcm179x *data = chip->model_data;
 326
 327         data->generic.ext_power_reg = OXYGEN_GPIO_DATA;
 328         data->generic.ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
 329         data->generic.ext_power_bit = GPIO_D2X_EXT_POWER;
 330         oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2X_EXT_POWER);
 331         xonar_init_ext_power(chip);
 332         xonar_d2_init(chip);
 333 }
 334
 335 static void xonar_hdav_init(struct oxygen *chip)
 336 {
 337         struct xonar_hdav *data = chip->model_data;
 338
 339         oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
 340                        OXYGEN_2WIRE_LENGTH_8 |
 341                        OXYGEN_2WIRE_INTERRUPT_MASK |
 342                        OXYGEN_2WIRE_SPEED_FAST);
 343
 344         data->pcm179x.generic.anti_pop_delay = 100;
 345         data->pcm179x.generic.output_enable_bit = GPIO_HDAV_OUTPUT_ENABLE;
 346         data->pcm179x.generic.ext_power_reg = OXYGEN_GPI_DATA;
 347         data->pcm179x.generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
 348         data->pcm179x.generic.ext_power_bit = GPI_EXT_POWER;
 349         data->pcm179x.dacs = chip->model.private_data ? 4 : 1;
 350
 351         pcm1796_init(chip);
 352
 353         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_INPUT_ROUTE);
 354         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_INPUT_ROUTE);
 355
 356         xonar_init_cs53x1(chip);
 357         xonar_init_ext_power(chip);
 358         xonar_hdmi_init(chip, &data->hdmi);
 359         xonar_enable_output(chip);
 360
 361         snd_component_add(chip->card, "PCM1796");
 362         snd_component_add(chip->card, "CS5381");
 363 }
 364
 365 static void xonar_st_init_i2c(struct oxygen *chip)
 366 {
 367         oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
 368                        OXYGEN_2WIRE_LENGTH_8 |
 369                        OXYGEN_2WIRE_INTERRUPT_MASK |
 370                        OXYGEN_2WIRE_SPEED_FAST);
 371 }
 372
 373 static void xonar_st_init_common(struct oxygen *chip)
 374 {
 375         struct xonar_pcm179x *data = chip->model_data;
 376
 377         data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
 378         data->dacs = chip->model.private_data ? 4 : 1;
 379         data->hp_gain_offset = 2*-18;
 380
 381         pcm1796_init(chip);
 382
 383         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
 384                           GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 385         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
 386                             GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 387
 388         xonar_init_cs53x1(chip);
 389         xonar_enable_output(chip);
 390
 391         snd_component_add(chip->card, "PCM1792A");
 392         snd_component_add(chip->card, "CS5381");
 393 }
 394
 395 static void cs2000_registers_init(struct oxygen *chip)
 396 {
 397         struct xonar_pcm179x *data = chip->model_data;
 398
 399         cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
 400         cs2000_write(chip, CS2000_DEV_CTRL, 0);
 401         cs2000_write(chip, CS2000_DEV_CFG_1,
 402                      CS2000_R_MOD_SEL_1 |
 403                      (0 << CS2000_R_SEL_SHIFT) |
 404                      CS2000_AUX_OUT_SRC_REF_CLK |
 405                      CS2000_EN_DEV_CFG_1);
 406         cs2000_write(chip, CS2000_DEV_CFG_2,
 407                      (0 << CS2000_LOCK_CLK_SHIFT) |
 408                      CS2000_FRAC_N_SRC_STATIC);
 409         cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
 410         cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
 411         cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
 412         cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
 413         cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
 414         cs2000_write(chip, CS2000_FUN_CFG_2, 0);
 415         cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
 416 }
 417
 418 static void xonar_st_init(struct oxygen *chip)
 419 {
 420         struct xonar_pcm179x *data = chip->model_data;
 421
 422         data->generic.anti_pop_delay = 100;
 423         data->has_cs2000 = 1;
 424         data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1;
 425
 426         oxygen_write16(chip, OXYGEN_I2S_A_FORMAT,
 427                        OXYGEN_RATE_48000 | OXYGEN_I2S_FORMAT_I2S |
 428                        OXYGEN_I2S_MCLK_128 | OXYGEN_I2S_BITS_16 |
 429                        OXYGEN_I2S_MASTER | OXYGEN_I2S_BCLK_64);
 430
 431         xonar_st_init_i2c(chip);
 432         cs2000_registers_init(chip);
 433         xonar_st_init_common(chip);
 434
 435         snd_component_add(chip->card, "CS2000");
 436 }
 437
 438 static void xonar_stx_init(struct oxygen *chip)
 439 {
 440         struct xonar_pcm179x *data = chip->model_data;
 441
 442         xonar_st_init_i2c(chip);
 443         data->generic.anti_pop_delay = 800;
 444         data->generic.ext_power_reg = OXYGEN_GPI_DATA;
 445         data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
 446         data->generic.ext_power_bit = GPI_EXT_POWER;
 447         xonar_init_ext_power(chip);
 448         xonar_st_init_common(chip);
 449 }
 450
 451 static void xonar_d2_cleanup(struct oxygen *chip)
 452 {
 453         xonar_disable_output(chip);
 454 }
 455
 456 static void xonar_hdav_cleanup(struct oxygen *chip)
 457 {
 458         xonar_hdmi_cleanup(chip);
 459         xonar_disable_output(chip);
 460         msleep(2);
 461 }
 462
 463 static void xonar_st_cleanup(struct oxygen *chip)
 464 {
 465         xonar_disable_output(chip);
 466 }
 467
 468 static void xonar_d2_suspend(struct oxygen *chip)
 469 {
 470         xonar_d2_cleanup(chip);
 471 }
 472
 473 static void xonar_hdav_suspend(struct oxygen *chip)
 474 {
 475         xonar_hdav_cleanup(chip);
 476 }
 477
 478 static void xonar_st_suspend(struct oxygen *chip)
 479 {
 480         xonar_st_cleanup(chip);
 481 }
 482
 483 static void xonar_d2_resume(struct oxygen *chip)
 484 {
 485         pcm1796_registers_init(chip);
 486         xonar_enable_output(chip);
 487 }
 488
 489 static void xonar_hdav_resume(struct oxygen *chip)
 490 {
 491         struct xonar_hdav *data = chip->model_data;
 492
 493         pcm1796_registers_init(chip);
 494         xonar_hdmi_resume(chip, &data->hdmi);
 495         xonar_enable_output(chip);
 496 }
 497
 498 static void xonar_stx_resume(struct oxygen *chip)
 499 {
 500         pcm1796_registers_init(chip);
 501         xonar_enable_output(chip);
 502 }
 503
 504 static void xonar_st_resume(struct oxygen *chip)
 505 {
 506         cs2000_registers_init(chip);
 507         xonar_stx_resume(chip);
 508 }
 509
 510 static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate)
 511 {
 512         struct xonar_pcm179x *data = chip->model_data;
 513
 514         if (rate <= 32000)
 515                 return OXYGEN_I2S_MCLK_512;
 516         else if (rate <= 48000 && data->os_128)
 517                 return OXYGEN_I2S_MCLK_512;
 518         else if (rate <= 96000)
 519                 return OXYGEN_I2S_MCLK_256;
 520         else
 521                 return OXYGEN_I2S_MCLK_128;
 522 }
 523
 524 static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip,
 525                                          unsigned int channel,
 526                                          struct snd_pcm_hw_params *params)
 527 {
 528         if (channel == PCM_MULTICH)
 529                 return mclk_from_rate(chip, params_rate(params));
 530         else
 531                 return oxygen_default_i2s_mclk(chip, channel, params);
 532 }
 533
 534 static void update_pcm1796_oversampling(struct oxygen *chip)
 535 {
 536         struct xonar_pcm179x *data = chip->model_data;
 537         unsigned int i;
 538         u8 reg;
 539
 540         if (data->current_rate <= 32000)
 541                 reg = PCM1796_OS_128;
 542         else if (data->current_rate <= 48000 && data->os_128)
 543                 reg = PCM1796_OS_128;
 544         else if (data->current_rate <= 96000 || data->os_128)
 545                 reg = PCM1796_OS_64;
 546         else
 547                 reg = PCM1796_OS_32;
 548         for (i = 0; i < data->dacs; ++i)
 549                 pcm1796_write_cached(chip, i, 20, reg);
 550 }
 551
 552 static void set_pcm1796_params(struct oxygen *chip,
 553                                struct snd_pcm_hw_params *params)
 554 {
 555         struct xonar_pcm179x *data = chip->model_data;
 556
 557         data->current_rate = params_rate(params);
 558         update_pcm1796_oversampling(chip);
 559 }
 560
 561 static void update_pcm1796_volume(struct oxygen *chip)
 562 {
 563         struct xonar_pcm179x *data = chip->model_data;
 564         unsigned int i;
 565         s8 gain_offset;
 566
 567         gain_offset = data->hp_active ? data->hp_gain_offset : 0;
 568         for (i = 0; i < data->dacs; ++i) {
 569                 pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
 570                                      + gain_offset);
 571                 pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
 572                                      + gain_offset);
 573         }
 574 }
 575
 576 static void update_pcm1796_mute(struct oxygen *chip)
 577 {
 578         struct xonar_pcm179x *data = chip->model_data;
 579         unsigned int i;
 580         u8 value;
 581
 582         value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 583         if (chip->dac_mute)
 584                 value |= PCM1796_MUTE;
 585         for (i = 0; i < data->dacs; ++i)
 586                 pcm1796_write_cached(chip, i, 18, value);
 587 }
 588
 589 static void update_cs2000_rate(struct oxygen *chip, unsigned int rate)
 590 {
 591         struct xonar_pcm179x *data = chip->model_data;
 592         u8 rate_mclk, reg;
 593
 594         switch (rate) {
 595                 /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
 596         case 32000:
 597                 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
 598                 break;
 599         case 44100:
 600                 if (data->os_128)
 601                         rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 602                 else
 603                         rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128;
 604                 break;
 605         default: /* 48000 */
 606                 if (data->os_128)
 607                         rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 608                 else
 609                         rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128;
 610                 break;
 611         case 64000:
 612                 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
 613                 break;
 614         case 88200:
 615                 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 616                 break;
 617         case 96000:
 618                 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 619                 break;
 620         case 176400:
 621                 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 622                 break;
 623         case 192000:
 624                 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 625                 break;
 626         }
 627         oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
 628                               OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
 629         if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
 630                 reg = CS2000_REF_CLK_DIV_1;
 631         else
 632                 reg = CS2000_REF_CLK_DIV_2;
 633         cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
 634 }
 635
 636 static void set_st_params(struct oxygen *chip,
 637                           struct snd_pcm_hw_params *params)
 638 {
 639         update_cs2000_rate(chip, params_rate(params));
 640         set_pcm1796_params(chip, params);
 641 }
 642
 643 static void set_hdav_params(struct oxygen *chip,
 644                             struct snd_pcm_hw_params *params)
 645 {
 646         struct xonar_hdav *data = chip->model_data;
 647
 648         set_pcm1796_params(chip, params);
 649         xonar_set_hdmi_params(chip, &data->hdmi, params);
 650 }
 651
 652 static const struct snd_kcontrol_new alt_switch = {
 653         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 654         .name = "Analog Loopback Switch",
 655         .info = snd_ctl_boolean_mono_info,
 656         .get = xonar_gpio_bit_switch_get,
 657         .put = xonar_gpio_bit_switch_put,
 658         .private_value = GPIO_D2_ALT,
 659 };
 660
 661 static int rolloff_info(struct snd_kcontrol *ctl,
 662                         struct snd_ctl_elem_info *info)
 663 {
 664         static const char *const names[2] = {
 665                 "Sharp Roll-off", "Slow Roll-off"
 666         };
 667
 668         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 669         info->count = 1;
 670         info->value.enumerated.items = 2;
 671         if (info->value.enumerated.item >= 2)
 672                 info->value.enumerated.item = 1;
 673         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 674         return 0;
 675 }
 676
 677 static int rolloff_get(struct snd_kcontrol *ctl,
 678                        struct snd_ctl_elem_value *value)
 679 {
 680         struct oxygen *chip = ctl->private_data;
 681         struct xonar_pcm179x *data = chip->model_data;
 682
 683         value->value.enumerated.item[0] =
 684                 (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] &
 685                  PCM1796_FLT_MASK) != PCM1796_FLT_SHARP;
 686         return 0;
 687 }
 688
 689 static int rolloff_put(struct snd_kcontrol *ctl,
 690                        struct snd_ctl_elem_value *value)
 691 {
 692         struct oxygen *chip = ctl->private_data;
 693         struct xonar_pcm179x *data = chip->model_data;
 694         unsigned int i;
 695         int changed;
 696         u8 reg;
 697
 698         mutex_lock(&chip->mutex);
 699         reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
 700         reg &= ~PCM1796_FLT_MASK;
 701         if (!value->value.enumerated.item[0])
 702                 reg |= PCM1796_FLT_SHARP;
 703         else
 704                 reg |= PCM1796_FLT_SLOW;
 705         changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
 706         if (changed) {
 707                 for (i = 0; i < data->dacs; ++i)
 708                         pcm1796_write(chip, i, 19, reg);
 709         }
 710         mutex_unlock(&chip->mutex);
 711         return changed;
 712 }
 713
 714 static const struct snd_kcontrol_new rolloff_control = {
 715         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 716         .name = "DAC Filter Playback Enum",
 717         .info = rolloff_info,
 718         .get = rolloff_get,
 719         .put = rolloff_put,
 720 };
 721
 722 static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
 723 {
 724         static const char *const names[2] = { "64x", "128x" };
 725
 726         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 727         info->count = 1;
 728         info->value.enumerated.items = 2;
 729         if (info->value.enumerated.item >= 2)
 730                 info->value.enumerated.item = 1;
 731         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 732         return 0;
 733 }
 734
 735 static int os_128_get(struct snd_kcontrol *ctl,
 736                       struct snd_ctl_elem_value *value)
 737 {
 738         struct oxygen *chip = ctl->private_data;
 739         struct xonar_pcm179x *data = chip->model_data;
 740
 741         value->value.enumerated.item[0] = data->os_128;
 742         return 0;
 743 }
 744
 745 static int os_128_put(struct snd_kcontrol *ctl,
 746                       struct snd_ctl_elem_value *value)
 747 {
 748         struct oxygen *chip = ctl->private_data;
 749         struct xonar_pcm179x *data = chip->model_data;
 750         int changed;
 751
 752         mutex_lock(&chip->mutex);
 753         changed = value->value.enumerated.item[0] != data->os_128;
 754         if (changed) {
 755                 data->os_128 = value->value.enumerated.item[0];
 756                 if (data->has_cs2000)
 757                         update_cs2000_rate(chip, data->current_rate);
 758                 oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
 759                                       mclk_from_rate(chip, data->current_rate),
 760                                       OXYGEN_I2S_MCLK_MASK);
 761                 update_pcm1796_oversampling(chip);
 762         }
 763         mutex_unlock(&chip->mutex);
 764         return changed;
 765 }
 766
 767 static const struct snd_kcontrol_new os_128_control = {
 768         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 769         .name = "DAC Oversampling Playback Enum",
 770         .info = os_128_info,
 771         .get = os_128_get,
 772         .put = os_128_put,
 773 };
 774
 775 static int st_output_switch_info(struct snd_kcontrol *ctl,
 776                                  struct snd_ctl_elem_info *info)
 777 {
 778         static const char *const names[3] = {
 779                 "Speakers", "Headphones", "FP Headphones"
 780         };
 781
 782         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 783         info->count = 1;
 784         info->value.enumerated.items = 3;
 785         if (info->value.enumerated.item >= 3)
 786                 info->value.enumerated.item = 2;
 787         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 788         return 0;
 789 }
 790
 791 static int st_output_switch_get(struct snd_kcontrol *ctl,
 792                                 struct snd_ctl_elem_value *value)
 793 {
 794         struct oxygen *chip = ctl->private_data;
 795         u16 gpio;
 796
 797         gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
 798         if (!(gpio & GPIO_ST_HP))
 799                 value->value.enumerated.item[0] = 0;
 800         else if (gpio & GPIO_ST_HP_REAR)
 801                 value->value.enumerated.item[0] = 1;
 802         else
 803                 value->value.enumerated.item[0] = 2;
 804         return 0;
 805 }
 806
 807
 808 static int st_output_switch_put(struct snd_kcontrol *ctl,
 809                                 struct snd_ctl_elem_value *value)
 810 {
 811         struct oxygen *chip = ctl->private_data;
 812         struct xonar_pcm179x *data = chip->model_data;
 813         u16 gpio_old, gpio;
 814
 815         mutex_lock(&chip->mutex);
 816         gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
 817         gpio = gpio_old;
 818         switch (value->value.enumerated.item[0]) {
 819         case 0:
 820                 gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
 821                 break;
 822         case 1:
 823                 gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
 824                 break;
 825         case 2:
 826                 gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
 827                 break;
 828         }
 829         oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
 830         data->hp_active = gpio & GPIO_ST_HP;
 831         update_pcm1796_volume(chip);
 832         mutex_unlock(&chip->mutex);
 833         return gpio != gpio_old;
 834 }
 835
 836 static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
 837                                     struct snd_ctl_elem_info *info)
 838 {
 839         static const char *const names[3] = {
 840                 "< 64 ohms", "64-300 ohms", "300-600 ohms"
 841         };
 842
 843         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 844         info->count = 1;
 845         info->value.enumerated.items = 3;
 846         if (info->value.enumerated.item > 2)
 847                 info->value.enumerated.item = 2;
 848         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 849         return 0;
 850 }
 851
 852 static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
 853                                    struct snd_ctl_elem_value *value)
 854 {
 855         struct oxygen *chip = ctl->private_data;
 856         struct xonar_pcm179x *data = chip->model_data;
 857
 858         mutex_lock(&chip->mutex);
 859         if (data->hp_gain_offset < 2*-6)
 860                 value->value.enumerated.item[0] = 0;
 861         else if (data->hp_gain_offset < 0)
 862                 value->value.enumerated.item[0] = 1;
 863         else
 864                 value->value.enumerated.item[0] = 2;
 865         mutex_unlock(&chip->mutex);
 866         return 0;
 867 }
 868
 869
 870 static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
 871                                    struct snd_ctl_elem_value *value)
 872 {
 873         static const s8 offsets[] = { 2*-18, 2*-6, 0 };
 874         struct oxygen *chip = ctl->private_data;
 875         struct xonar_pcm179x *data = chip->model_data;
 876         s8 offset;
 877         int changed;
 878
 879         if (value->value.enumerated.item[0] > 2)
 880                 return -EINVAL;
 881         offset = offsets[value->value.enumerated.item[0]];
 882         mutex_lock(&chip->mutex);
 883         changed = offset != data->hp_gain_offset;
 884         if (changed) {
 885                 data->hp_gain_offset = offset;
 886                 update_pcm1796_volume(chip);
 887         }
 888         mutex_unlock(&chip->mutex);
 889         return changed;
 890 }
 891
 892 static const struct snd_kcontrol_new st_controls[] = {
 893         {
 894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 895                 .name = "Analog Output",
 896                 .info = st_output_switch_info,
 897                 .get = st_output_switch_get,
 898                 .put = st_output_switch_put,
 899         },
 900         {
 901                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 902                 .name = "Headphones Impedance Playback Enum",
 903                 .info = st_hp_volume_offset_info,
 904                 .get = st_hp_volume_offset_get,
 905                 .put = st_hp_volume_offset_put,
 906         },
 907 };
 908
 909 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
 910                                        unsigned int reg, unsigned int mute)
 911 {
 912         if (reg == AC97_LINE) {
 913                 spin_lock_irq(&chip->reg_lock);
 914                 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
 915                                       mute ? GPIO_INPUT_ROUTE : 0,
 916                                       GPIO_INPUT_ROUTE);
 917                 spin_unlock_irq(&chip->reg_lock);
 918         }
 919 }
 920
 921 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
 922
 923 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
 924 {
 925         if (!strncmp(template->name, "CD Capture ", 11))
 926                 /* CD in is actually connected to the video in pin */
 927                 template->private_value ^= AC97_CD ^ AC97_VIDEO;
 928         return 0;
 929 }
 930
 931 static int add_pcm1796_controls(struct oxygen *chip)
 932 {
 933         int err;
 934
 935         err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
 936         if (err < 0)
 937                 return err;
 938         err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip));
 939         if (err < 0)
 940                 return err;
 941         return 0;
 942 }
 943
 944 static int xonar_d2_mixer_init(struct oxygen *chip)
 945 {
 946         int err;
 947
 948         err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
 949         if (err < 0)
 950                 return err;
 951         err = add_pcm1796_controls(chip);
 952         if (err < 0)
 953                 return err;
 954         return 0;
 955 }
 956
 957 static int xonar_hdav_mixer_init(struct oxygen *chip)
 958 {
 959         return add_pcm1796_controls(chip);
 960 }
 961
 962 static int xonar_st_mixer_init(struct oxygen *chip)
 963 {
 964         unsigned int i;
 965         int err;
 966
 967         for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
 968                 err = snd_ctl_add(chip->card,
 969                                   snd_ctl_new1(&st_controls[i], chip));
 970                 if (err < 0)
 971                         return err;
 972         }
 973         err = add_pcm1796_controls(chip);
 974         if (err < 0)
 975                 return err;
 976         return 0;
 977 }
 978
 979 static const struct oxygen_model model_xonar_d2 = {
 980         .longname = "Asus Virtuoso 200",
 981         .chip = "AV200",
 982         .init = xonar_d2_init,
 983         .control_filter = xonar_d2_control_filter,
 984         .mixer_init = xonar_d2_mixer_init,
 985         .cleanup = xonar_d2_cleanup,
 986         .suspend = xonar_d2_suspend,
 987         .resume = xonar_d2_resume,
 988         .get_i2s_mclk = get_pcm1796_i2s_mclk,
 989         .set_dac_params = set_pcm1796_params,
 990         .set_adc_params = xonar_set_cs53x1_params,
 991         .update_dac_volume = update_pcm1796_volume,
 992         .update_dac_mute = update_pcm1796_mute,
 993         .dac_tlv = pcm1796_db_scale,
 994         .model_data_size = sizeof(struct xonar_pcm179x),
 995         .device_config = PLAYBACK_0_TO_I2S |
 996                          PLAYBACK_1_TO_SPDIF |
 997                          CAPTURE_0_FROM_I2S_2 |
 998                          CAPTURE_1_FROM_SPDIF |
 999                          MIDI_OUTPUT |
1000                          MIDI_INPUT |
1001                          AC97_CD_INPUT,
1002         .dac_channels = 8,
1003         .dac_volume_min = 255 - 2*60,
1004         .dac_volume_max = 255,
1005         .misc_flags = OXYGEN_MISC_MIDI,
1006         .function_flags = OXYGEN_FUNCTION_SPI |
1007                           OXYGEN_FUNCTION_ENABLE_SPI_4_5,
1008         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1009         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1010 };
1011
1012 static const struct oxygen_model model_xonar_hdav = {
1013         .longname = "Asus Virtuoso 200",
1014         .chip = "AV200",
1015         .init = xonar_hdav_init,
1016         .mixer_init = xonar_hdav_mixer_init,
1017         .cleanup = xonar_hdav_cleanup,
1018         .suspend = xonar_hdav_suspend,
1019         .resume = xonar_hdav_resume,
1020         .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
1021         .get_i2s_mclk = get_pcm1796_i2s_mclk,
1022         .set_dac_params = set_hdav_params,
1023         .set_adc_params = xonar_set_cs53x1_params,
1024         .update_dac_volume = update_pcm1796_volume,
1025         .update_dac_mute = update_pcm1796_mute,
1026         .uart_input = xonar_hdmi_uart_input,
1027         .ac97_switch = xonar_line_mic_ac97_switch,
1028         .dac_tlv = pcm1796_db_scale,
1029         .model_data_size = sizeof(struct xonar_hdav),
1030         .device_config = PLAYBACK_0_TO_I2S |
1031                          PLAYBACK_1_TO_SPDIF |
1032                          CAPTURE_0_FROM_I2S_2 |
1033                          CAPTURE_1_FROM_SPDIF,
1034         .dac_channels = 8,
1035         .dac_volume_min = 255 - 2*60,
1036         .dac_volume_max = 255,
1037         .misc_flags = OXYGEN_MISC_MIDI,
1038         .function_flags = OXYGEN_FUNCTION_2WIRE,
1039         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1040         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1041 };
1042
1043 static const struct oxygen_model model_xonar_st = {
1044         .longname = "Asus Virtuoso 100",
1045         .chip = "AV200",
1046         .init = xonar_st_init,
1047         .mixer_init = xonar_st_mixer_init,
1048         .cleanup = xonar_st_cleanup,
1049         .suspend = xonar_st_suspend,
1050         .resume = xonar_st_resume,
1051         .get_i2s_mclk = get_pcm1796_i2s_mclk,
1052         .set_dac_params = set_st_params,
1053         .set_adc_params = xonar_set_cs53x1_params,
1054         .update_dac_volume = update_pcm1796_volume,
1055         .update_dac_mute = update_pcm1796_mute,
1056         .ac97_switch = xonar_line_mic_ac97_switch,
1057         .dac_tlv = pcm1796_db_scale,
1058         .model_data_size = sizeof(struct xonar_pcm179x),
1059         .device_config = PLAYBACK_0_TO_I2S |
1060                          PLAYBACK_1_TO_SPDIF |
1061                          CAPTURE_0_FROM_I2S_2,
1062         .dac_channels = 2,
1063         .dac_volume_min = 255 - 2*60,
1064         .dac_volume_max = 255,
1065         .function_flags = OXYGEN_FUNCTION_2WIRE,
1066         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1067         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1068 };
1069
1070 int __devinit get_xonar_pcm179x_model(struct oxygen *chip,
1071                                       const struct pci_device_id *id)
1072 {
1073         switch (id->subdevice) {
1074         case 0x8269:
1075                 chip->model = model_xonar_d2;
1076                 chip->model.shortname = "Xonar D2";
1077                 break;
1078         case 0x82b7:
1079                 chip->model = model_xonar_d2;
1080                 chip->model.shortname = "Xonar D2X";
1081                 chip->model.init = xonar_d2x_init;
1082                 break;
1083         case 0x8314:
1084                 chip->model = model_xonar_hdav;
1085                 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1086                 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1087                 default:
1088                         chip->model.shortname = "Xonar HDAV1.3";
1089                         break;
1090                 case GPIO_DB_H6:
1091                         chip->model.shortname = "Xonar HDAV1.3+H6";
1092                         chip->model.private_data = 1;
1093                         break;
1094                 }
1095                 break;
1096         case 0x835d:
1097                 chip->model = model_xonar_st;
1098                 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1099                 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1100                 default:
1101                         chip->model.shortname = "Xonar ST";
1102                         break;
1103                 case GPIO_DB_H6:
1104                         chip->model.shortname = "Xonar ST+H6";
1105                         chip->model.dac_channels = 8;
1106                         chip->model.private_data = 1;
1107                         break;
1108                 }
1109                 break;
1110         case 0x835c:
1111                 chip->model = model_xonar_st;
1112                 chip->model.shortname = "Xonar STX";
1113                 chip->model.init = xonar_stx_init;
1114                 chip->model.resume = xonar_stx_resume;
1115                 chip->model.set_dac_params = set_pcm1796_params;
1116                 break;
1117         case 0x835e:
1118                 snd_printk(KERN_ERR "the HDAV1.3 Slim is not supported\n");
1119                 return -ENODEV;
1120         default:
1121                 return -EINVAL;
1122         }
1123         return 0;
1124 }