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.anti_pop_delay = 100;
 378         data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE;
 379         data->dacs = chip->model.private_data ? 4 : 1;
 380         data->hp_gain_offset = 2*-18;
 381
 382         pcm1796_init(chip);
 383
 384         oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
 385                           GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 386         oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
 387                             GPIO_INPUT_ROUTE | GPIO_ST_HP_REAR | GPIO_ST_HP);
 388
 389         xonar_init_cs53x1(chip);
 390         xonar_enable_output(chip);
 391
 392         snd_component_add(chip->card, "PCM1792A");
 393         snd_component_add(chip->card, "CS5381");
 394 }
 395
 396 static void cs2000_registers_init(struct oxygen *chip)
 397 {
 398         struct xonar_pcm179x *data = chip->model_data;
 399
 400         cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_FREEZE);
 401         cs2000_write(chip, CS2000_DEV_CTRL, 0);
 402         cs2000_write(chip, CS2000_DEV_CFG_1,
 403                      CS2000_R_MOD_SEL_1 |
 404                      (0 << CS2000_R_SEL_SHIFT) |
 405                      CS2000_AUX_OUT_SRC_REF_CLK |
 406                      CS2000_EN_DEV_CFG_1);
 407         cs2000_write(chip, CS2000_DEV_CFG_2,
 408                      (0 << CS2000_LOCK_CLK_SHIFT) |
 409                      CS2000_FRAC_N_SRC_STATIC);
 410         cs2000_write(chip, CS2000_RATIO_0 + 0, 0x00); /* 1.0 */
 411         cs2000_write(chip, CS2000_RATIO_0 + 1, 0x10);
 412         cs2000_write(chip, CS2000_RATIO_0 + 2, 0x00);
 413         cs2000_write(chip, CS2000_RATIO_0 + 3, 0x00);
 414         cs2000_write(chip, CS2000_FUN_CFG_1, data->cs2000_fun_cfg_1);
 415         cs2000_write(chip, CS2000_FUN_CFG_2, 0);
 416         cs2000_write(chip, CS2000_GLOBAL_CFG, CS2000_EN_DEV_CFG_2);
 417 }
 418
 419 static void xonar_st_init(struct oxygen *chip)
 420 {
 421         struct xonar_pcm179x *data = chip->model_data;
 422
 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.ext_power_reg = OXYGEN_GPI_DATA;
 444         data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
 445         data->generic.ext_power_bit = GPI_EXT_POWER;
 446         xonar_init_ext_power(chip);
 447         xonar_st_init_common(chip);
 448 }
 449
 450 static void xonar_d2_cleanup(struct oxygen *chip)
 451 {
 452         xonar_disable_output(chip);
 453 }
 454
 455 static void xonar_hdav_cleanup(struct oxygen *chip)
 456 {
 457         xonar_hdmi_cleanup(chip);
 458         xonar_disable_output(chip);
 459         msleep(2);
 460 }
 461
 462 static void xonar_st_cleanup(struct oxygen *chip)
 463 {
 464         xonar_disable_output(chip);
 465 }
 466
 467 static void xonar_d2_suspend(struct oxygen *chip)
 468 {
 469         xonar_d2_cleanup(chip);
 470 }
 471
 472 static void xonar_hdav_suspend(struct oxygen *chip)
 473 {
 474         xonar_hdav_cleanup(chip);
 475 }
 476
 477 static void xonar_st_suspend(struct oxygen *chip)
 478 {
 479         xonar_st_cleanup(chip);
 480 }
 481
 482 static void xonar_d2_resume(struct oxygen *chip)
 483 {
 484         pcm1796_registers_init(chip);
 485         xonar_enable_output(chip);
 486 }
 487
 488 static void xonar_hdav_resume(struct oxygen *chip)
 489 {
 490         struct xonar_hdav *data = chip->model_data;
 491
 492         pcm1796_registers_init(chip);
 493         xonar_hdmi_resume(chip, &data->hdmi);
 494         xonar_enable_output(chip);
 495 }
 496
 497 static void xonar_stx_resume(struct oxygen *chip)
 498 {
 499         pcm1796_registers_init(chip);
 500         xonar_enable_output(chip);
 501 }
 502
 503 static void xonar_st_resume(struct oxygen *chip)
 504 {
 505         cs2000_registers_init(chip);
 506         xonar_stx_resume(chip);
 507 }
 508
 509 static unsigned int mclk_from_rate(struct oxygen *chip, unsigned int rate)
 510 {
 511         struct xonar_pcm179x *data = chip->model_data;
 512
 513         if (rate <= 32000)
 514                 return OXYGEN_I2S_MCLK_512;
 515         else if (rate <= 48000 && data->os_128)
 516                 return OXYGEN_I2S_MCLK_512;
 517         else if (rate <= 96000)
 518                 return OXYGEN_I2S_MCLK_256;
 519         else
 520                 return OXYGEN_I2S_MCLK_128;
 521 }
 522
 523 static unsigned int get_pcm1796_i2s_mclk(struct oxygen *chip,
 524                                          unsigned int channel,
 525                                          struct snd_pcm_hw_params *params)
 526 {
 527         if (channel == PCM_MULTICH)
 528                 return mclk_from_rate(chip, params_rate(params));
 529         else
 530                 return oxygen_default_i2s_mclk(chip, channel, params);
 531 }
 532
 533 static void update_pcm1796_oversampling(struct oxygen *chip)
 534 {
 535         struct xonar_pcm179x *data = chip->model_data;
 536         unsigned int i;
 537         u8 reg;
 538
 539         if (data->current_rate <= 32000)
 540                 reg = PCM1796_OS_128;
 541         else if (data->current_rate <= 48000 && data->os_128)
 542                 reg = PCM1796_OS_128;
 543         else if (data->current_rate <= 96000 || data->os_128)
 544                 reg = PCM1796_OS_64;
 545         else
 546                 reg = PCM1796_OS_32;
 547         for (i = 0; i < data->dacs; ++i)
 548                 pcm1796_write_cached(chip, i, 20, reg);
 549 }
 550
 551 static void set_pcm1796_params(struct oxygen *chip,
 552                                struct snd_pcm_hw_params *params)
 553 {
 554         struct xonar_pcm179x *data = chip->model_data;
 555
 556         data->current_rate = params_rate(params);
 557         update_pcm1796_oversampling(chip);
 558 }
 559
 560 static void update_pcm1796_volume(struct oxygen *chip)
 561 {
 562         struct xonar_pcm179x *data = chip->model_data;
 563         unsigned int i;
 564         s8 gain_offset;
 565
 566         gain_offset = data->hp_active ? data->hp_gain_offset : 0;
 567         for (i = 0; i < data->dacs; ++i) {
 568                 pcm1796_write_cached(chip, i, 16, chip->dac_volume[i * 2]
 569                                      + gain_offset);
 570                 pcm1796_write_cached(chip, i, 17, chip->dac_volume[i * 2 + 1]
 571                                      + gain_offset);
 572         }
 573 }
 574
 575 static void update_pcm1796_mute(struct oxygen *chip)
 576 {
 577         struct xonar_pcm179x *data = chip->model_data;
 578         unsigned int i;
 579         u8 value;
 580
 581         value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
 582         if (chip->dac_mute)
 583                 value |= PCM1796_MUTE;
 584         for (i = 0; i < data->dacs; ++i)
 585                 pcm1796_write_cached(chip, i, 18, value);
 586 }
 587
 588 static void update_cs2000_rate(struct oxygen *chip, unsigned int rate)
 589 {
 590         struct xonar_pcm179x *data = chip->model_data;
 591         u8 rate_mclk, reg;
 592
 593         switch (rate) {
 594                 /* XXX Why is the I2S A MCLK half the actual I2S MCLK? */
 595         case 32000:
 596                 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
 597                 break;
 598         case 44100:
 599                 if (data->os_128)
 600                         rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 601                 else
 602                         rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_128;
 603                 break;
 604         default: /* 48000 */
 605                 if (data->os_128)
 606                         rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 607                 else
 608                         rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_128;
 609                 break;
 610         case 64000:
 611                 rate_mclk = OXYGEN_RATE_32000 | OXYGEN_I2S_MCLK_256;
 612                 break;
 613         case 88200:
 614                 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 615                 break;
 616         case 96000:
 617                 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 618                 break;
 619         case 176400:
 620                 rate_mclk = OXYGEN_RATE_44100 | OXYGEN_I2S_MCLK_256;
 621                 break;
 622         case 192000:
 623                 rate_mclk = OXYGEN_RATE_48000 | OXYGEN_I2S_MCLK_256;
 624                 break;
 625         }
 626         oxygen_write16_masked(chip, OXYGEN_I2S_A_FORMAT, rate_mclk,
 627                               OXYGEN_I2S_RATE_MASK | OXYGEN_I2S_MCLK_MASK);
 628         if ((rate_mclk & OXYGEN_I2S_MCLK_MASK) <= OXYGEN_I2S_MCLK_128)
 629                 reg = CS2000_REF_CLK_DIV_1;
 630         else
 631                 reg = CS2000_REF_CLK_DIV_2;
 632         cs2000_write_cached(chip, CS2000_FUN_CFG_1, reg);
 633 }
 634
 635 static void set_st_params(struct oxygen *chip,
 636                           struct snd_pcm_hw_params *params)
 637 {
 638         update_cs2000_rate(chip, params_rate(params));
 639         set_pcm1796_params(chip, params);
 640 }
 641
 642 static void set_hdav_params(struct oxygen *chip,
 643                             struct snd_pcm_hw_params *params)
 644 {
 645         struct xonar_hdav *data = chip->model_data;
 646
 647         set_pcm1796_params(chip, params);
 648         xonar_set_hdmi_params(chip, &data->hdmi, params);
 649 }
 650
 651 static const struct snd_kcontrol_new alt_switch = {
 652         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 653         .name = "Analog Loopback Switch",
 654         .info = snd_ctl_boolean_mono_info,
 655         .get = xonar_gpio_bit_switch_get,
 656         .put = xonar_gpio_bit_switch_put,
 657         .private_value = GPIO_D2_ALT,
 658 };
 659
 660 static int rolloff_info(struct snd_kcontrol *ctl,
 661                         struct snd_ctl_elem_info *info)
 662 {
 663         static const char *const names[2] = {
 664                 "Sharp Roll-off", "Slow Roll-off"
 665         };
 666
 667         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 668         info->count = 1;
 669         info->value.enumerated.items = 2;
 670         if (info->value.enumerated.item >= 2)
 671                 info->value.enumerated.item = 1;
 672         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 673         return 0;
 674 }
 675
 676 static int rolloff_get(struct snd_kcontrol *ctl,
 677                        struct snd_ctl_elem_value *value)
 678 {
 679         struct oxygen *chip = ctl->private_data;
 680         struct xonar_pcm179x *data = chip->model_data;
 681
 682         value->value.enumerated.item[0] =
 683                 (data->pcm1796_regs[0][19 - PCM1796_REG_BASE] &
 684                  PCM1796_FLT_MASK) != PCM1796_FLT_SHARP;
 685         return 0;
 686 }
 687
 688 static int rolloff_put(struct snd_kcontrol *ctl,
 689                        struct snd_ctl_elem_value *value)
 690 {
 691         struct oxygen *chip = ctl->private_data;
 692         struct xonar_pcm179x *data = chip->model_data;
 693         unsigned int i;
 694         int changed;
 695         u8 reg;
 696
 697         mutex_lock(&chip->mutex);
 698         reg = data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
 699         reg &= ~PCM1796_FLT_MASK;
 700         if (!value->value.enumerated.item[0])
 701                 reg |= PCM1796_FLT_SHARP;
 702         else
 703                 reg |= PCM1796_FLT_SLOW;
 704         changed = reg != data->pcm1796_regs[0][19 - PCM1796_REG_BASE];
 705         if (changed) {
 706                 for (i = 0; i < data->dacs; ++i)
 707                         pcm1796_write(chip, i, 19, reg);
 708         }
 709         mutex_unlock(&chip->mutex);
 710         return changed;
 711 }
 712
 713 static const struct snd_kcontrol_new rolloff_control = {
 714         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 715         .name = "DAC Filter Playback Enum",
 716         .info = rolloff_info,
 717         .get = rolloff_get,
 718         .put = rolloff_put,
 719 };
 720
 721 static int os_128_info(struct snd_kcontrol *ctl, struct snd_ctl_elem_info *info)
 722 {
 723         static const char *const names[2] = { "64x", "128x" };
 724
 725         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 726         info->count = 1;
 727         info->value.enumerated.items = 2;
 728         if (info->value.enumerated.item >= 2)
 729                 info->value.enumerated.item = 1;
 730         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 731         return 0;
 732 }
 733
 734 static int os_128_get(struct snd_kcontrol *ctl,
 735                       struct snd_ctl_elem_value *value)
 736 {
 737         struct oxygen *chip = ctl->private_data;
 738         struct xonar_pcm179x *data = chip->model_data;
 739
 740         value->value.enumerated.item[0] = data->os_128;
 741         return 0;
 742 }
 743
 744 static int os_128_put(struct snd_kcontrol *ctl,
 745                       struct snd_ctl_elem_value *value)
 746 {
 747         struct oxygen *chip = ctl->private_data;
 748         struct xonar_pcm179x *data = chip->model_data;
 749         int changed;
 750
 751         mutex_lock(&chip->mutex);
 752         changed = value->value.enumerated.item[0] != data->os_128;
 753         if (changed) {
 754                 data->os_128 = value->value.enumerated.item[0];
 755                 if (data->has_cs2000)
 756                         update_cs2000_rate(chip, data->current_rate);
 757                 oxygen_write16_masked(chip, OXYGEN_I2S_MULTICH_FORMAT,
 758                                       mclk_from_rate(chip, data->current_rate),
 759                                       OXYGEN_I2S_MCLK_MASK);
 760                 update_pcm1796_oversampling(chip);
 761         }
 762         mutex_unlock(&chip->mutex);
 763         return changed;
 764 }
 765
 766 static const struct snd_kcontrol_new os_128_control = {
 767         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 768         .name = "DAC Oversampling Playback Enum",
 769         .info = os_128_info,
 770         .get = os_128_get,
 771         .put = os_128_put,
 772 };
 773
 774 static int st_output_switch_info(struct snd_kcontrol *ctl,
 775                                  struct snd_ctl_elem_info *info)
 776 {
 777         static const char *const names[3] = {
 778                 "Speakers", "Headphones", "FP Headphones"
 779         };
 780
 781         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 782         info->count = 1;
 783         info->value.enumerated.items = 3;
 784         if (info->value.enumerated.item >= 3)
 785                 info->value.enumerated.item = 2;
 786         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 787         return 0;
 788 }
 789
 790 static int st_output_switch_get(struct snd_kcontrol *ctl,
 791                                 struct snd_ctl_elem_value *value)
 792 {
 793         struct oxygen *chip = ctl->private_data;
 794         u16 gpio;
 795
 796         gpio = oxygen_read16(chip, OXYGEN_GPIO_DATA);
 797         if (!(gpio & GPIO_ST_HP))
 798                 value->value.enumerated.item[0] = 0;
 799         else if (gpio & GPIO_ST_HP_REAR)
 800                 value->value.enumerated.item[0] = 1;
 801         else
 802                 value->value.enumerated.item[0] = 2;
 803         return 0;
 804 }
 805
 806
 807 static int st_output_switch_put(struct snd_kcontrol *ctl,
 808                                 struct snd_ctl_elem_value *value)
 809 {
 810         struct oxygen *chip = ctl->private_data;
 811         struct xonar_pcm179x *data = chip->model_data;
 812         u16 gpio_old, gpio;
 813
 814         mutex_lock(&chip->mutex);
 815         gpio_old = oxygen_read16(chip, OXYGEN_GPIO_DATA);
 816         gpio = gpio_old;
 817         switch (value->value.enumerated.item[0]) {
 818         case 0:
 819                 gpio &= ~(GPIO_ST_HP | GPIO_ST_HP_REAR);
 820                 break;
 821         case 1:
 822                 gpio |= GPIO_ST_HP | GPIO_ST_HP_REAR;
 823                 break;
 824         case 2:
 825                 gpio = (gpio | GPIO_ST_HP) & ~GPIO_ST_HP_REAR;
 826                 break;
 827         }
 828         oxygen_write16(chip, OXYGEN_GPIO_DATA, gpio);
 829         data->hp_active = gpio & GPIO_ST_HP;
 830         update_pcm1796_volume(chip);
 831         mutex_unlock(&chip->mutex);
 832         return gpio != gpio_old;
 833 }
 834
 835 static int st_hp_volume_offset_info(struct snd_kcontrol *ctl,
 836                                     struct snd_ctl_elem_info *info)
 837 {
 838         static const char *const names[3] = {
 839                 "< 64 ohms", "64-300 ohms", "300-600 ohms"
 840         };
 841
 842         info->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 843         info->count = 1;
 844         info->value.enumerated.items = 3;
 845         if (info->value.enumerated.item > 2)
 846                 info->value.enumerated.item = 2;
 847         strcpy(info->value.enumerated.name, names[info->value.enumerated.item]);
 848         return 0;
 849 }
 850
 851 static int st_hp_volume_offset_get(struct snd_kcontrol *ctl,
 852                                    struct snd_ctl_elem_value *value)
 853 {
 854         struct oxygen *chip = ctl->private_data;
 855         struct xonar_pcm179x *data = chip->model_data;
 856
 857         mutex_lock(&chip->mutex);
 858         if (data->hp_gain_offset < 2*-6)
 859                 value->value.enumerated.item[0] = 0;
 860         else if (data->hp_gain_offset < 0)
 861                 value->value.enumerated.item[0] = 1;
 862         else
 863                 value->value.enumerated.item[0] = 2;
 864         mutex_unlock(&chip->mutex);
 865         return 0;
 866 }
 867
 868
 869 static int st_hp_volume_offset_put(struct snd_kcontrol *ctl,
 870                                    struct snd_ctl_elem_value *value)
 871 {
 872         static const s8 offsets[] = { 2*-18, 2*-6, 0 };
 873         struct oxygen *chip = ctl->private_data;
 874         struct xonar_pcm179x *data = chip->model_data;
 875         s8 offset;
 876         int changed;
 877
 878         if (value->value.enumerated.item[0] > 2)
 879                 return -EINVAL;
 880         offset = offsets[value->value.enumerated.item[0]];
 881         mutex_lock(&chip->mutex);
 882         changed = offset != data->hp_gain_offset;
 883         if (changed) {
 884                 data->hp_gain_offset = offset;
 885                 update_pcm1796_volume(chip);
 886         }
 887         mutex_unlock(&chip->mutex);
 888         return changed;
 889 }
 890
 891 static const struct snd_kcontrol_new st_controls[] = {
 892         {
 893                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 894                 .name = "Analog Output",
 895                 .info = st_output_switch_info,
 896                 .get = st_output_switch_get,
 897                 .put = st_output_switch_put,
 898         },
 899         {
 900                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
 901                 .name = "Headphones Impedance Playback Enum",
 902                 .info = st_hp_volume_offset_info,
 903                 .get = st_hp_volume_offset_get,
 904                 .put = st_hp_volume_offset_put,
 905         },
 906 };
 907
 908 static void xonar_line_mic_ac97_switch(struct oxygen *chip,
 909                                        unsigned int reg, unsigned int mute)
 910 {
 911         if (reg == AC97_LINE) {
 912                 spin_lock_irq(&chip->reg_lock);
 913                 oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
 914                                       mute ? GPIO_INPUT_ROUTE : 0,
 915                                       GPIO_INPUT_ROUTE);
 916                 spin_unlock_irq(&chip->reg_lock);
 917         }
 918 }
 919
 920 static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -6000, 50, 0);
 921
 922 static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
 923 {
 924         if (!strncmp(template->name, "CD Capture ", 11))
 925                 /* CD in is actually connected to the video in pin */
 926                 template->private_value ^= AC97_CD ^ AC97_VIDEO;
 927         return 0;
 928 }
 929
 930 static int add_pcm1796_controls(struct oxygen *chip)
 931 {
 932         int err;
 933
 934         err = snd_ctl_add(chip->card, snd_ctl_new1(&rolloff_control, chip));
 935         if (err < 0)
 936                 return err;
 937         err = snd_ctl_add(chip->card, snd_ctl_new1(&os_128_control, chip));
 938         if (err < 0)
 939                 return err;
 940         return 0;
 941 }
 942
 943 static int xonar_d2_mixer_init(struct oxygen *chip)
 944 {
 945         int err;
 946
 947         err = snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
 948         if (err < 0)
 949                 return err;
 950         err = add_pcm1796_controls(chip);
 951         if (err < 0)
 952                 return err;
 953         return 0;
 954 }
 955
 956 static int xonar_hdav_mixer_init(struct oxygen *chip)
 957 {
 958         return add_pcm1796_controls(chip);
 959 }
 960
 961 static int xonar_st_mixer_init(struct oxygen *chip)
 962 {
 963         unsigned int i;
 964         int err;
 965
 966         for (i = 0; i < ARRAY_SIZE(st_controls); ++i) {
 967                 err = snd_ctl_add(chip->card,
 968                                   snd_ctl_new1(&st_controls[i], chip));
 969                 if (err < 0)
 970                         return err;
 971         }
 972         err = add_pcm1796_controls(chip);
 973         if (err < 0)
 974                 return err;
 975         return 0;
 976 }
 977
 978 static const struct oxygen_model model_xonar_d2 = {
 979         .longname = "Asus Virtuoso 200",
 980         .chip = "AV200",
 981         .init = xonar_d2_init,
 982         .control_filter = xonar_d2_control_filter,
 983         .mixer_init = xonar_d2_mixer_init,
 984         .cleanup = xonar_d2_cleanup,
 985         .suspend = xonar_d2_suspend,
 986         .resume = xonar_d2_resume,
 987         .get_i2s_mclk = get_pcm1796_i2s_mclk,
 988         .set_dac_params = set_pcm1796_params,
 989         .set_adc_params = xonar_set_cs53x1_params,
 990         .update_dac_volume = update_pcm1796_volume,
 991         .update_dac_mute = update_pcm1796_mute,
 992         .dac_tlv = pcm1796_db_scale,
 993         .model_data_size = sizeof(struct xonar_pcm179x),
 994         .device_config = PLAYBACK_0_TO_I2S |
 995                          PLAYBACK_1_TO_SPDIF |
 996                          CAPTURE_0_FROM_I2S_2 |
 997                          CAPTURE_1_FROM_SPDIF |
 998                          MIDI_OUTPUT |
 999                          MIDI_INPUT |
1000                          AC97_CD_INPUT,
1001         .dac_channels = 8,
1002         .dac_volume_min = 255 - 2*60,
1003         .dac_volume_max = 255,
1004         .misc_flags = OXYGEN_MISC_MIDI,
1005         .function_flags = OXYGEN_FUNCTION_SPI |
1006                           OXYGEN_FUNCTION_ENABLE_SPI_4_5,
1007         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1008         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1009 };
1010
1011 static const struct oxygen_model model_xonar_hdav = {
1012         .longname = "Asus Virtuoso 200",
1013         .chip = "AV200",
1014         .init = xonar_hdav_init,
1015         .mixer_init = xonar_hdav_mixer_init,
1016         .cleanup = xonar_hdav_cleanup,
1017         .suspend = xonar_hdav_suspend,
1018         .resume = xonar_hdav_resume,
1019         .pcm_hardware_filter = xonar_hdmi_pcm_hardware_filter,
1020         .get_i2s_mclk = get_pcm1796_i2s_mclk,
1021         .set_dac_params = set_hdav_params,
1022         .set_adc_params = xonar_set_cs53x1_params,
1023         .update_dac_volume = update_pcm1796_volume,
1024         .update_dac_mute = update_pcm1796_mute,
1025         .uart_input = xonar_hdmi_uart_input,
1026         .ac97_switch = xonar_line_mic_ac97_switch,
1027         .dac_tlv = pcm1796_db_scale,
1028         .model_data_size = sizeof(struct xonar_hdav),
1029         .device_config = PLAYBACK_0_TO_I2S |
1030                          PLAYBACK_1_TO_SPDIF |
1031                          CAPTURE_0_FROM_I2S_2 |
1032                          CAPTURE_1_FROM_SPDIF,
1033         .dac_channels = 8,
1034         .dac_volume_min = 255 - 2*60,
1035         .dac_volume_max = 255,
1036         .misc_flags = OXYGEN_MISC_MIDI,
1037         .function_flags = OXYGEN_FUNCTION_2WIRE,
1038         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1039         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1040 };
1041
1042 static const struct oxygen_model model_xonar_st = {
1043         .longname = "Asus Virtuoso 100",
1044         .chip = "AV200",
1045         .init = xonar_st_init,
1046         .mixer_init = xonar_st_mixer_init,
1047         .cleanup = xonar_st_cleanup,
1048         .suspend = xonar_st_suspend,
1049         .resume = xonar_st_resume,
1050         .get_i2s_mclk = get_pcm1796_i2s_mclk,
1051         .set_dac_params = set_st_params,
1052         .set_adc_params = xonar_set_cs53x1_params,
1053         .update_dac_volume = update_pcm1796_volume,
1054         .update_dac_mute = update_pcm1796_mute,
1055         .ac97_switch = xonar_line_mic_ac97_switch,
1056         .dac_tlv = pcm1796_db_scale,
1057         .model_data_size = sizeof(struct xonar_pcm179x),
1058         .device_config = PLAYBACK_0_TO_I2S |
1059                          PLAYBACK_1_TO_SPDIF |
1060                          CAPTURE_0_FROM_I2S_2,
1061         .dac_channels = 2,
1062         .dac_volume_min = 255 - 2*60,
1063         .dac_volume_max = 255,
1064         .function_flags = OXYGEN_FUNCTION_2WIRE,
1065         .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1066         .adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
1067 };
1068
1069 int __devinit get_xonar_pcm179x_model(struct oxygen *chip,
1070                                       const struct pci_device_id *id)
1071 {
1072         switch (id->subdevice) {
1073         case 0x8269:
1074                 chip->model = model_xonar_d2;
1075                 chip->model.shortname = "Xonar D2";
1076                 break;
1077         case 0x82b7:
1078                 chip->model = model_xonar_d2;
1079                 chip->model.shortname = "Xonar D2X";
1080                 chip->model.init = xonar_d2x_init;
1081                 break;
1082         case 0x8314:
1083                 chip->model = model_xonar_hdav;
1084                 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1085                 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1086                 default:
1087                         chip->model.shortname = "Xonar HDAV1.3";
1088                         break;
1089                 case GPIO_DB_H6:
1090                         chip->model.shortname = "Xonar HDAV1.3+H6";
1091                         chip->model.private_data = 1;
1092                         break;
1093                 }
1094                 break;
1095         case 0x835d:
1096                 chip->model = model_xonar_st;
1097                 oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DB_MASK);
1098                 switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) & GPIO_DB_MASK) {
1099                 default:
1100                         chip->model.shortname = "Xonar ST";
1101                         break;
1102                 case GPIO_DB_H6:
1103                         chip->model.shortname = "Xonar ST+H6";
1104                         chip->model.dac_channels = 8;
1105                         chip->model.private_data = 1;
1106                         break;
1107                 }
1108                 break;
1109         case 0x835c:
1110                 chip->model = model_xonar_st;
1111                 chip->model.shortname = "Xonar STX";
1112                 chip->model.init = xonar_stx_init;
1113                 chip->model.resume = xonar_stx_resume;
1114                 chip->model.set_dac_params = set_pcm1796_params;
1115                 break;
1116         case 0x835e:
1117                 snd_printk(KERN_ERR "the HDAV1.3 Slim is not supported\n");
1118                 return -ENODEV;
1119         default:
1120                 return -EINVAL;
1121         }
1122         return 0;
1123 }