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