virtuoso.c 25.2 KB
Newer Older
C
Clemens Ladisch 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * C-Media CMI8788 driver for Asus Xonar cards
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 *
 *
 *  This driver is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License, version 2.
 *
 *  This driver is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this driver; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

/*
21 22 23
 * Xonar D2/D2X
 * ------------
 *
24 25
 * CMI8788:
 *
C
Clemens Ladisch 已提交
26
 * SPI 0 -> 1st PCM1796 (front)
27
 * SPI 1 -> 2nd PCM1796 (surround)
C
Clemens Ladisch 已提交
28
 * SPI 2 -> 3rd PCM1796 (center/LFE)
29
 * SPI 4 -> 4th PCM1796 (back)
C
Clemens Ladisch 已提交
30 31 32
 *
 * GPIO 2 -> M0 of CS5381
 * GPIO 3 -> M1 of CS5381
33
 * GPIO 5 <- external power present (D2X only)
C
Clemens Ladisch 已提交
34
 * GPIO 7 -> ALT
35
 * GPIO 8 -> enable output to speakers
C
Clemens Ladisch 已提交
36 37
 */

38
/*
39 40
 * Xonar D1/DX
 * -----------
41 42 43 44 45 46
 *
 * CMI8788:
 *
 * I²C <-> CS4398 (front)
 *     <-> CS4362A (surround, center/LFE, back)
 *
47
 * GPI 0 <- external power present (DX only)
48 49
 *
 * GPIO 0 -> enable output to speakers
50
 * GPIO 1 -> enable front panel I/O
51 52
 * GPIO 2 -> M0 of CS5361
 * GPIO 3 -> M1 of CS5361
53
 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
54 55 56 57 58 59 60 61 62 63 64
 *
 * CS4398:
 *
 * AD0 <- 1
 * AD1 <- 1
 *
 * CS4362A:
 *
 * AD0 <- 0
 */

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
/*
 * Xonar HDAV1.3 (Deluxe)
 * ----------------------
 *
 * CMI8788:
 *
 * I²C <-> PCM1796 (front)
 *
 * GPI 0 <- external power present
 *
 * GPIO 0 -> enable output to speakers
 * GPIO 2 -> M0 of CS5381
 * GPIO 3 -> M1 of CS5381
 * GPIO 8 -> route input jack to line-in (0) or mic-in (1)
 *
 * TXD -> HDMI controller
 * RXD <- HDMI controller
 *
 * PCM1796 front: AD1,0 <- 0,0
 *
 * no daughterboard
 * ----------------
 *
 * GPIO 4 <- 1
 *
 * H6 daughterboard
 * ----------------
 *
 * GPIO 4 <- 0
 * GPIO 5 <- 0
 *
 * I²C <-> PCM1796 (surround)
 *     <-> PCM1796 (center/LFE)
 *     <-> PCM1796 (back)
 *
 * PCM1796 surround:   AD1,0 <- 0,1
 * PCM1796 center/LFE: AD1,0 <- 1,0
 * PCM1796 back:       AD1,0 <- 1,1
 *
 * unknown daughterboard
 * ---------------------
 *
 * GPIO 4 <- 0
 * GPIO 5 <- 1
 *
 * I²C <-> CS4362A (surround, center/LFE, back)
 *
 * CS4362A: AD0 <- 0
 */

C
Clemens Ladisch 已提交
115 116
#include <linux/pci.h>
#include <linux/delay.h>
117 118
#include <linux/mutex.h>
#include <sound/ac97_codec.h>
119
#include <sound/asoundef.h>
C
Clemens Ladisch 已提交
120 121 122 123
#include <sound/control.h>
#include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h>
124
#include <sound/pcm_params.h>
C
Clemens Ladisch 已提交
125 126
#include <sound/tlv.h>
#include "oxygen.h"
127
#include "cm9780.h"
128
#include "pcm1796.h"
129 130
#include "cs4398.h"
#include "cs4362a.h"
C
Clemens Ladisch 已提交
131 132

MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
133
MODULE_DESCRIPTION("Asus AVx00 driver");
134
MODULE_LICENSE("GPL v2");
135
MODULE_SUPPORTED_DEVICE("{{Asus,AV100},{Asus,AV200}}");
C
Clemens Ladisch 已提交
136 137 138 139 140 141 142 143 144 145 146 147

static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;

module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "card index");
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string");
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "enable card");

148 149 150
enum {
	MODEL_D2,
	MODEL_D2X,
151
	MODEL_D1,
152
	MODEL_DX,
153 154
	MODEL_HDAV,	/* without daughterboard */
	MODEL_HDAV_H6,	/* with H6 daughterboard */
155 156
};

C
Clemens Ladisch 已提交
157
static struct pci_device_id xonar_ids[] __devinitdata = {
158
	{ OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data = MODEL_D2 },
159
	{ OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data = MODEL_DX },
160
	{ OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X },
161
	{ OXYGEN_PCI_SUBID(0x1043, 0x8314), .driver_data = MODEL_HDAV },
162
	{ OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 },
C
Clemens Ladisch 已提交
163 164 165 166
	{ }
};
MODULE_DEVICE_TABLE(pci, xonar_ids);

167

168 169 170 171 172
#define GPIO_CS53x1_M_MASK	0x000c
#define GPIO_CS53x1_M_SINGLE	0x0000
#define GPIO_CS53x1_M_DOUBLE	0x0004
#define GPIO_CS53x1_M_QUAD	0x0008

173 174 175
#define GPIO_D2X_EXT_POWER	0x0020
#define GPIO_D2_ALT		0x0080
#define GPIO_D2_OUTPUT_ENABLE	0x0100
176

177 178
#define GPI_DX_EXT_POWER	0x01
#define GPIO_DX_OUTPUT_ENABLE	0x0001
179
#define GPIO_DX_FRONT_PANEL	0x0002
180
#define GPIO_DX_INPUT_ROUTE	0x0100
181

182 183 184 185
#define GPIO_HDAV_DB_MASK	0x0030
#define GPIO_HDAV_DB_H6		0x0000
#define GPIO_HDAV_DB_XX		0x0020

186
#define I2C_DEVICE_PCM1796(i)	(0x98 + ((i) << 1))	/* 10011, ADx=i, /W=0 */
187 188 189
#define I2C_DEVICE_CS4398	0x9e	/* 10011, AD1=1, AD0=1, /W=0 */
#define I2C_DEVICE_CS4362A	0x30	/* 001100, AD0=0, /W=0 */

190
struct xonar_data {
191
	unsigned int model;
192
	unsigned int anti_pop_delay;
193
	unsigned int dacs;
194 195 196 197
	u16 output_enable_bit;
	u8 ext_power_reg;
	u8 ext_power_int_reg;
	u8 ext_power_bit;
198
	u8 has_power;
199 200 201
	u8 pcm1796_oversampling;
	u8 cs4398_fm;
	u8 cs4362a_fm;
202
	u8 hdmi_params[5];
203 204
};

205 206
static void xonar_gpio_changed(struct oxygen *chip);

207 208
static inline void pcm1796_write_spi(struct oxygen *chip, unsigned int codec,
				     u8 reg, u8 value)
C
Clemens Ladisch 已提交
209 210 211
{
	/* maps ALSA channel pair number to SPI output */
	static const u8 codec_map[4] = {
212
		0, 1, 2, 4
C
Clemens Ladisch 已提交
213
	};
214
	oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
C
Clemens Ladisch 已提交
215
			 OXYGEN_SPI_DATA_LENGTH_2 |
216
			 OXYGEN_SPI_CLOCK_160 |
C
Clemens Ladisch 已提交
217
			 (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
218
			 OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
C
Clemens Ladisch 已提交
219 220 221
			 (reg << 8) | value);
}

222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
static inline void pcm1796_write_i2c(struct oxygen *chip, unsigned int codec,
				     u8 reg, u8 value)
{
	oxygen_write_i2c(chip, I2C_DEVICE_PCM1796(codec), reg, value);
}

static void pcm1796_write(struct oxygen *chip, unsigned int codec,
			  u8 reg, u8 value)
{
	if ((chip->model.function_flags & OXYGEN_FUNCTION_2WIRE_SPI_MASK) ==
	    OXYGEN_FUNCTION_SPI)
		pcm1796_write_spi(chip, codec, reg, value);
	else
		pcm1796_write_i2c(chip, codec, reg, value);
}

238 239 240 241 242 243 244 245 246 247
static void cs4398_write(struct oxygen *chip, u8 reg, u8 value)
{
	oxygen_write_i2c(chip, I2C_DEVICE_CS4398, reg, value);
}

static void cs4362a_write(struct oxygen *chip, u8 reg, u8 value)
{
	oxygen_write_i2c(chip, I2C_DEVICE_CS4362A, reg, value);
}

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265
static void hdmi_write_command(struct oxygen *chip, u8 command,
			       unsigned int count, const u8 *params)
{
	unsigned int i;
	u8 checksum;

	oxygen_write_uart(chip, 0xfb);
	oxygen_write_uart(chip, 0xef);
	oxygen_write_uart(chip, command);
	oxygen_write_uart(chip, count);
	for (i = 0; i < count; ++i)
		oxygen_write_uart(chip, params[i]);
	checksum = 0xfb + 0xef + command + count;
	for (i = 0; i < count; ++i)
		checksum += params[i];
	oxygen_write_uart(chip, checksum);
}

266 267 268 269 270 271 272 273
static void xonar_enable_output(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;

	msleep(data->anti_pop_delay);
	oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
}

274 275 276 277 278 279 280 281
static void xonar_common_init(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;

	if (data->ext_power_reg) {
		oxygen_set_bits8(chip, data->ext_power_int_reg,
				 data->ext_power_bit);
		chip->interrupt_mask |= OXYGEN_INT_GPIO;
282
		chip->model.gpio_changed = xonar_gpio_changed;
283 284 285
		data->has_power = !!(oxygen_read8(chip, data->ext_power_reg)
				     & data->ext_power_bit);
	}
286 287
	oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
			  GPIO_CS53x1_M_MASK | data->output_enable_bit);
288 289 290
	oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
			      GPIO_CS53x1_M_SINGLE, GPIO_CS53x1_M_MASK);
	oxygen_ac97_set_bits(chip, 0, CM9780_JACK, CM9780_FMIC2MIC);
291
	xonar_enable_output(chip);
292 293
}

294 295
static void update_pcm1796_volume(struct oxygen *chip)
{
296
	struct xonar_data *data = chip->model_data;
297 298
	unsigned int i;

299
	for (i = 0; i < data->dacs; ++i) {
300 301 302 303 304 305 306
		pcm1796_write(chip, i, 16, chip->dac_volume[i * 2]);
		pcm1796_write(chip, i, 17, chip->dac_volume[i * 2 + 1]);
	}
}

static void update_pcm1796_mute(struct oxygen *chip)
{
307
	struct xonar_data *data = chip->model_data;
308 309 310 311 312 313
	unsigned int i;
	u8 value;

	value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
	if (chip->dac_mute)
		value |= PCM1796_MUTE;
314
	for (i = 0; i < data->dacs; ++i)
315 316 317
		pcm1796_write(chip, i, 18, value);
}

318
static void pcm1796_init(struct oxygen *chip)
C
Clemens Ladisch 已提交
319
{
320
	struct xonar_data *data = chip->model_data;
C
Clemens Ladisch 已提交
321 322
	unsigned int i;

323
	for (i = 0; i < data->dacs; ++i) {
324
		pcm1796_write(chip, i, 19, PCM1796_FLT_SHARP | PCM1796_ATS_1);
325
		pcm1796_write(chip, i, 20, data->pcm1796_oversampling);
326
		pcm1796_write(chip, i, 21, 0);
C
Clemens Ladisch 已提交
327
	}
328 329
	update_pcm1796_mute(chip); /* set ATLD before ATL/ATR */
	update_pcm1796_volume(chip);
330 331 332 333 334 335 336 337 338
}

static void xonar_d2_init(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;

	data->anti_pop_delay = 300;
	data->output_enable_bit = GPIO_D2_OUTPUT_ENABLE;
	data->pcm1796_oversampling = PCM1796_OS_64;
339 340 341 342 343 344 345
	if (data->model == MODEL_D2X) {
		data->ext_power_reg = OXYGEN_GPIO_DATA;
		data->ext_power_int_reg = OXYGEN_GPIO_INTERRUPT_MASK;
		data->ext_power_bit = GPIO_D2X_EXT_POWER;
		oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
				    GPIO_D2X_EXT_POWER);
	}
346 347

	pcm1796_init(chip);
C
Clemens Ladisch 已提交
348

349 350 351 352
	oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_D2_ALT);
	oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_D2_ALT);

	xonar_common_init(chip);
C
Clemens Ladisch 已提交
353 354 355 356 357

	snd_component_add(chip->card, "PCM1796");
	snd_component_add(chip->card, "CS5381");
}

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
static void update_cs4362a_volumes(struct oxygen *chip)
{
	u8 mute;

	mute = chip->dac_mute ? CS4362A_MUTE : 0;
	cs4362a_write(chip, 7, (127 - chip->dac_volume[2]) | mute);
	cs4362a_write(chip, 8, (127 - chip->dac_volume[3]) | mute);
	cs4362a_write(chip, 10, (127 - chip->dac_volume[4]) | mute);
	cs4362a_write(chip, 11, (127 - chip->dac_volume[5]) | mute);
	cs4362a_write(chip, 13, (127 - chip->dac_volume[6]) | mute);
	cs4362a_write(chip, 14, (127 - chip->dac_volume[7]) | mute);
}

static void update_cs43xx_volume(struct oxygen *chip)
{
	cs4398_write(chip, 5, (127 - chip->dac_volume[0]) * 2);
	cs4398_write(chip, 6, (127 - chip->dac_volume[1]) * 2);
	update_cs4362a_volumes(chip);
}

static void update_cs43xx_mute(struct oxygen *chip)
{
	u8 reg;

	reg = CS4398_MUTEP_LOW | CS4398_PAMUTE;
	if (chip->dac_mute)
		reg |= CS4398_MUTE_B | CS4398_MUTE_A;
	cs4398_write(chip, 4, reg);
	update_cs4362a_volumes(chip);
}

389
static void cs43xx_init(struct oxygen *chip)
390 391 392 393 394 395 396
{
	struct xonar_data *data = chip->model_data;

	/* set CPEN (control port mode) and power down */
	cs4398_write(chip, 8, CS4398_CPEN | CS4398_PDN);
	cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
	/* configure */
397
	cs4398_write(chip, 2, data->cs4398_fm);
398 399 400 401 402 403 404 405
	cs4398_write(chip, 3, CS4398_ATAPI_B_R | CS4398_ATAPI_A_L);
	cs4398_write(chip, 7, CS4398_RMP_DN | CS4398_RMP_UP |
		     CS4398_ZERO_CROSS | CS4398_SOFT_RAMP);
	cs4362a_write(chip, 0x02, CS4362A_DIF_LJUST);
	cs4362a_write(chip, 0x03, CS4362A_MUTEC_6 | CS4362A_AMUTE |
		      CS4362A_RMP_UP | CS4362A_ZERO_CROSS | CS4362A_SOFT_RAMP);
	cs4362a_write(chip, 0x04, CS4362A_RMP_DN | CS4362A_DEM_NONE);
	cs4362a_write(chip, 0x05, 0);
406 407 408
	cs4362a_write(chip, 0x06, data->cs4362a_fm);
	cs4362a_write(chip, 0x09, data->cs4362a_fm);
	cs4362a_write(chip, 0x0c, data->cs4362a_fm);
409 410
	update_cs43xx_volume(chip);
	update_cs43xx_mute(chip);
411 412 413
	/* clear power down */
	cs4398_write(chip, 8, CS4398_CPEN);
	cs4362a_write(chip, 0x01, CS4362A_CPEN);
414 415
}

416
static void xonar_d1_init(struct oxygen *chip)
417 418 419 420 421 422 423 424
{
	struct xonar_data *data = chip->model_data;

	data->anti_pop_delay = 800;
	data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
	data->cs4398_fm = CS4398_FM_SINGLE | CS4398_DEM_NONE | CS4398_DIF_LJUST;
	data->cs4362a_fm = CS4362A_FM_SINGLE |
		CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
425 426 427 428 429
	if (data->model == MODEL_DX) {
		data->ext_power_reg = OXYGEN_GPI_DATA;
		data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
		data->ext_power_bit = GPI_DX_EXT_POWER;
	}
430 431 432 433 434 435 436

	oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
		       OXYGEN_2WIRE_LENGTH_8 |
		       OXYGEN_2WIRE_INTERRUPT_MASK |
		       OXYGEN_2WIRE_SPEED_FAST);

	cs43xx_init(chip);
437 438

	oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
439 440 441
			  GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE);
	oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
			    GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE);
442 443 444 445 446 447 448 449

	xonar_common_init(chip);

	snd_component_add(chip->card, "CS4398");
	snd_component_add(chip->card, "CS4362A");
	snd_component_add(chip->card, "CS5361");
}

450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
static void xonar_hdav_init(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;
	u8 param;

	oxygen_write16(chip, OXYGEN_2WIRE_BUS_STATUS,
		       OXYGEN_2WIRE_LENGTH_8 |
		       OXYGEN_2WIRE_INTERRUPT_MASK |
		       OXYGEN_2WIRE_SPEED_FAST);

	data->anti_pop_delay = 100;
	data->output_enable_bit = GPIO_DX_OUTPUT_ENABLE;
	data->ext_power_reg = OXYGEN_GPI_DATA;
	data->ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK;
	data->ext_power_bit = GPI_DX_EXT_POWER;
	data->pcm1796_oversampling = PCM1796_OS_64;

	pcm1796_init(chip);

	oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, GPIO_DX_INPUT_ROUTE);
	oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DX_INPUT_ROUTE);

	oxygen_reset_uart(chip);
	param = 0;
	hdmi_write_command(chip, 0x61, 1, &param);
	param = 1;
	hdmi_write_command(chip, 0x74, 1, &param);
	data->hdmi_params[1] = IEC958_AES3_CON_FS_48000;
	data->hdmi_params[4] = 1;
	hdmi_write_command(chip, 0x54, 5, data->hdmi_params);

	xonar_common_init(chip);

	snd_component_add(chip->card, "PCM1796");
	snd_component_add(chip->card, "CS5381");
}

487
static void xonar_disable_output(struct oxygen *chip)
C
Clemens Ladisch 已提交
488
{
489 490 491
	struct xonar_data *data = chip->model_data;

	oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA, data->output_enable_bit);
C
Clemens Ladisch 已提交
492 493
}

494 495 496 497 498
static void xonar_d2_cleanup(struct oxygen *chip)
{
	xonar_disable_output(chip);
}

499
static void xonar_d1_cleanup(struct oxygen *chip)
500
{
501
	xonar_disable_output(chip);
502 503 504 505
	cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
	oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC);
}

506 507 508 509 510 511 512 513
static void xonar_hdav_cleanup(struct oxygen *chip)
{
	u8 param = 0;

	hdmi_write_command(chip, 0x74, 1, &param);
	xonar_disable_output(chip);
}

514 515 516 517 518 519 520 521 522 523
static void xonar_d2_suspend(struct oxygen *chip)
{
	xonar_d2_cleanup(chip);
}

static void xonar_d1_suspend(struct oxygen *chip)
{
	xonar_d1_cleanup(chip);
}

524 525 526 527 528 529
static void xonar_hdav_suspend(struct oxygen *chip)
{
	xonar_hdav_cleanup(chip);
	msleep(2);
}

C
Clemens Ladisch 已提交
530 531 532 533 534 535
static void xonar_d2_resume(struct oxygen *chip)
{
	pcm1796_init(chip);
	xonar_enable_output(chip);
}

536
static void xonar_d1_resume(struct oxygen *chip)
C
Clemens Ladisch 已提交
537 538 539 540 541
{
	cs43xx_init(chip);
	xonar_enable_output(chip);
}

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
static void xonar_hdav_resume(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;
	u8 param;

	oxygen_reset_uart(chip);
	param = 0;
	hdmi_write_command(chip, 0x61, 1, &param);
	param = 1;
	hdmi_write_command(chip, 0x74, 1, &param);
	hdmi_write_command(chip, 0x54, 5, data->hdmi_params);
	pcm1796_init(chip);
	xonar_enable_output(chip);
}

static void xonar_hdav_pcm_hardware_filter(unsigned int channel,
					   struct snd_pcm_hardware *hardware)
{
	if (channel == PCM_MULTICH) {
		hardware->rates = SNDRV_PCM_RATE_44100 |
				  SNDRV_PCM_RATE_48000 |
				  SNDRV_PCM_RATE_96000 |
				  SNDRV_PCM_RATE_192000;
		hardware->rate_min = 44100;
	}
}

C
Clemens Ladisch 已提交
569 570 571
static void set_pcm1796_params(struct oxygen *chip,
			       struct snd_pcm_hw_params *params)
{
572
	struct xonar_data *data = chip->model_data;
C
Clemens Ladisch 已提交
573 574
	unsigned int i;

575 576
	data->pcm1796_oversampling =
		params_rate(params) >= 96000 ? PCM1796_OS_32 : PCM1796_OS_64;
577
	for (i = 0; i < data->dacs; ++i)
578
		pcm1796_write(chip, i, 20, data->pcm1796_oversampling);
C
Clemens Ladisch 已提交
579 580
}

581
static void set_cs53x1_params(struct oxygen *chip,
C
Clemens Ladisch 已提交
582 583 584 585 586
			      struct snd_pcm_hw_params *params)
{
	unsigned int value;

	if (params_rate(params) <= 54000)
587
		value = GPIO_CS53x1_M_SINGLE;
C
Clemens Ladisch 已提交
588
	else if (params_rate(params) <= 108000)
589
		value = GPIO_CS53x1_M_DOUBLE;
C
Clemens Ladisch 已提交
590
	else
591
		value = GPIO_CS53x1_M_QUAD;
592
	oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
593
			      value, GPIO_CS53x1_M_MASK);
C
Clemens Ladisch 已提交
594 595
}

596 597 598
static void set_cs43xx_params(struct oxygen *chip,
			      struct snd_pcm_hw_params *params)
{
599
	struct xonar_data *data = chip->model_data;
600

601 602
	data->cs4398_fm = CS4398_DEM_NONE | CS4398_DIF_LJUST;
	data->cs4362a_fm = CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
603
	if (params_rate(params) <= 50000) {
604 605
		data->cs4398_fm |= CS4398_FM_SINGLE;
		data->cs4362a_fm |= CS4362A_FM_SINGLE;
606
	} else if (params_rate(params) <= 100000) {
607 608
		data->cs4398_fm |= CS4398_FM_DOUBLE;
		data->cs4362a_fm |= CS4362A_FM_DOUBLE;
609
	} else {
610 611
		data->cs4398_fm |= CS4398_FM_QUAD;
		data->cs4362a_fm |= CS4362A_FM_QUAD;
612
	}
613 614 615 616
	cs4398_write(chip, 2, data->cs4398_fm);
	cs4362a_write(chip, 0x06, data->cs4362a_fm);
	cs4362a_write(chip, 0x09, data->cs4362a_fm);
	cs4362a_write(chip, 0x0c, data->cs4362a_fm);
617 618
}

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
static void set_hdmi_params(struct oxygen *chip,
			    struct snd_pcm_hw_params *params)
{
	struct xonar_data *data = chip->model_data;

	data->hdmi_params[0] = 0; /* 1 = non-audio */
	switch (params_rate(params)) {
	case 44100:
		data->hdmi_params[1] = IEC958_AES3_CON_FS_44100;
		break;
	case 48000:
		data->hdmi_params[1] = IEC958_AES3_CON_FS_48000;
		break;
	default: /* 96000 */
		data->hdmi_params[1] = IEC958_AES3_CON_FS_96000;
		break;
	case 192000:
		data->hdmi_params[1] = IEC958_AES3_CON_FS_192000;
		break;
	}
	data->hdmi_params[2] = params_channels(params) / 2 - 1;
	if (params_format(params) == SNDRV_PCM_FORMAT_S16_LE)
		data->hdmi_params[3] = 0;
	else
		data->hdmi_params[3] = 0xc0;
	data->hdmi_params[4] = 1; /* ? */
	hdmi_write_command(chip, 0x54, 5, data->hdmi_params);
}

static void set_hdav_params(struct oxygen *chip,
			    struct snd_pcm_hw_params *params)
{
	set_pcm1796_params(chip, params);
	set_hdmi_params(chip, params);
}

655 656 657 658 659
static void xonar_gpio_changed(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;
	u8 has_power;

660 661
	has_power = !!(oxygen_read8(chip, data->ext_power_reg)
		       & data->ext_power_bit);
662 663 664 665 666 667 668 669 670 671 672 673
	if (has_power != data->has_power) {
		data->has_power = has_power;
		if (has_power) {
			snd_printk(KERN_NOTICE "power restored\n");
		} else {
			snd_printk(KERN_CRIT
				   "Hey! Don't unplug the power cable!\n");
			/* TODO: stop PCMs */
		}
	}
}

674 675 676 677 678
static void xonar_hdav_uart_input(struct oxygen *chip)
{
	if (chip->uart_input_count >= 2 &&
	    chip->uart_input[chip->uart_input_count - 2] == 'O' &&
	    chip->uart_input[chip->uart_input_count - 1] == 'K') {
C
Clemens Ladisch 已提交
679
		printk(KERN_DEBUG "message from Xonar HDAV HDMI chip received:\n");
680 681 682 683 684 685
		print_hex_dump_bytes("", DUMP_PREFIX_OFFSET,
				     chip->uart_input, chip->uart_input_count);
		chip->uart_input_count = 0;
	}
}

686 687
static int gpio_bit_switch_get(struct snd_kcontrol *ctl,
			       struct snd_ctl_elem_value *value)
C
Clemens Ladisch 已提交
688 689
{
	struct oxygen *chip = ctl->private_data;
690
	u16 bit = ctl->private_value;
C
Clemens Ladisch 已提交
691 692

	value->value.integer.value[0] =
693
		!!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit);
C
Clemens Ladisch 已提交
694 695 696
	return 0;
}

697 698
static int gpio_bit_switch_put(struct snd_kcontrol *ctl,
			       struct snd_ctl_elem_value *value)
C
Clemens Ladisch 已提交
699 700
{
	struct oxygen *chip = ctl->private_data;
701
	u16 bit = ctl->private_value;
C
Clemens Ladisch 已提交
702 703 704 705 706 707
	u16 old_bits, new_bits;
	int changed;

	spin_lock_irq(&chip->reg_lock);
	old_bits = oxygen_read16(chip, OXYGEN_GPIO_DATA);
	if (value->value.integer.value[0])
708
		new_bits = old_bits | bit;
C
Clemens Ladisch 已提交
709
	else
710
		new_bits = old_bits & ~bit;
C
Clemens Ladisch 已提交
711 712 713 714 715 716 717 718 719 720 721
	changed = new_bits != old_bits;
	if (changed)
		oxygen_write16(chip, OXYGEN_GPIO_DATA, new_bits);
	spin_unlock_irq(&chip->reg_lock);
	return changed;
}

static const struct snd_kcontrol_new alt_switch = {
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
	.name = "Analog Loopback Switch",
	.info = snd_ctl_boolean_mono_info,
722 723 724
	.get = gpio_bit_switch_get,
	.put = gpio_bit_switch_put,
	.private_value = GPIO_D2_ALT,
C
Clemens Ladisch 已提交
725 726
};

727
static const struct snd_kcontrol_new front_panel_switch = {
728
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
729 730
	.name = "Front Panel Switch",
	.info = snd_ctl_boolean_mono_info,
731 732 733
	.get = gpio_bit_switch_get,
	.put = gpio_bit_switch_put,
	.private_value = GPIO_DX_FRONT_PANEL,
734 735
};

736 737
static void xonar_line_mic_ac97_switch(struct oxygen *chip,
				       unsigned int reg, unsigned int mute)
738 739 740 741 742 743 744 745 746 747
{
	if (reg == AC97_LINE) {
		spin_lock_irq(&chip->reg_lock);
		oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
				      mute ? GPIO_DX_INPUT_ROUTE : 0,
				      GPIO_DX_INPUT_ROUTE);
		spin_unlock_irq(&chip->reg_lock);
	}
}

C
Clemens Ladisch 已提交
748
static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -12000, 50, 0);
749
static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -12700, 100, 0);
C
Clemens Ladisch 已提交
750

751
static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
752
{
753
	if (!strncmp(template->name, "CD Capture ", 11))
754
		/* CD in is actually connected to the video in pin */
755 756 757 758
		template->private_value ^= AC97_CD ^ AC97_VIDEO;
	return 0;
}

759
static int xonar_d1_control_filter(struct snd_kcontrol_new *template)
760
{
761
	if (!strncmp(template->name, "CD Capture ", 11))
762 763 764 765
		return 1; /* no CD input */
	return 0;
}

766
static int xonar_d2_mixer_init(struct oxygen *chip)
C
Clemens Ladisch 已提交
767 768 769 770
{
	return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
}

771
static int xonar_d1_mixer_init(struct oxygen *chip)
772
{
773
	return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip));
774 775
}

776 777 778 779 780 781 782
static int xonar_model_probe(struct oxygen *chip, unsigned long driver_data)
{
	static const char *const names[] = {
		[MODEL_D1]	= "Xonar D1",
		[MODEL_DX]	= "Xonar DX",
		[MODEL_D2]	= "Xonar D2",
		[MODEL_D2X]	= "Xonar D2X",
783 784
		[MODEL_HDAV]	= "Xonar HDAV1.3",
		[MODEL_HDAV_H6]	= "Xonar HDAV1.3+H6",
785
	};
786 787 788 789 790
	static const u8 dacs[] = {
		[MODEL_D1]	= 2,
		[MODEL_DX]	= 2,
		[MODEL_D2]	= 4,
		[MODEL_D2X]	= 4,
791 792
		[MODEL_HDAV]	= 1,
		[MODEL_HDAV_H6]	= 4,
793
	};
794 795 796
	struct xonar_data *data = chip->model_data;

	data->model = driver_data;
797 798 799 800 801 802 803 804 805 806 807 808 809
	if (data->model == MODEL_HDAV) {
		oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL,
				    GPIO_HDAV_DB_MASK);
		switch (oxygen_read16(chip, OXYGEN_GPIO_DATA) &
			GPIO_HDAV_DB_MASK) {
		case GPIO_HDAV_DB_H6:
			data->model = MODEL_HDAV_H6;
			break;
		case GPIO_HDAV_DB_XX:
			snd_printk(KERN_ERR "unknown daughterboard\n");
			return -ENODEV;
		}
	}
810 811

	data->dacs = dacs[data->model];
812 813 814 815 816 817 818 819 820 821 822 823
	chip->model.shortname = names[data->model];
	return 0;
}

static const struct oxygen_model model_xonar_d2 = {
	.longname = "Asus Virtuoso 200",
	.chip = "AV200",
	.owner = THIS_MODULE,
	.probe = xonar_model_probe,
	.init = xonar_d2_init,
	.control_filter = xonar_d2_control_filter,
	.mixer_init = xonar_d2_mixer_init,
824 825
	.cleanup = xonar_d2_cleanup,
	.suspend = xonar_d2_suspend,
826 827 828 829 830 831 832
	.resume = xonar_d2_resume,
	.set_dac_params = set_pcm1796_params,
	.set_adc_params = set_cs53x1_params,
	.update_dac_volume = update_pcm1796_volume,
	.update_dac_mute = update_pcm1796_mute,
	.dac_tlv = pcm1796_db_scale,
	.model_data_size = sizeof(struct xonar_data),
833 834 835
	.device_config = PLAYBACK_0_TO_I2S |
			 PLAYBACK_1_TO_SPDIF |
			 CAPTURE_0_FROM_I2S_2 |
836 837 838
			 CAPTURE_1_FROM_SPDIF |
			 MIDI_OUTPUT |
			 MIDI_INPUT,
839 840 841 842
	.dac_channels = 8,
	.dac_volume_min = 0x0f,
	.dac_volume_max = 0xff,
	.misc_flags = OXYGEN_MISC_MIDI,
843 844 845
	.function_flags = OXYGEN_FUNCTION_SPI |
			  OXYGEN_FUNCTION_ENABLE_SPI_4_5,
	.dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
846 847 848 849 850 851 852 853 854 855 856 857
	.adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
};

static const struct oxygen_model model_xonar_d1 = {
	.longname = "Asus Virtuoso 100",
	.chip = "AV200",
	.owner = THIS_MODULE,
	.probe = xonar_model_probe,
	.init = xonar_d1_init,
	.control_filter = xonar_d1_control_filter,
	.mixer_init = xonar_d1_mixer_init,
	.cleanup = xonar_d1_cleanup,
858
	.suspend = xonar_d1_suspend,
859 860 861 862 863
	.resume = xonar_d1_resume,
	.set_dac_params = set_cs43xx_params,
	.set_adc_params = set_cs53x1_params,
	.update_dac_volume = update_cs43xx_volume,
	.update_dac_mute = update_cs43xx_mute,
864
	.ac97_switch = xonar_line_mic_ac97_switch,
865 866
	.dac_tlv = cs4362a_db_scale,
	.model_data_size = sizeof(struct xonar_data),
867 868 869
	.device_config = PLAYBACK_0_TO_I2S |
			 PLAYBACK_1_TO_SPDIF |
			 CAPTURE_0_FROM_I2S_2,
870 871 872 873 874 875
	.dac_channels = 8,
	.dac_volume_min = 0,
	.dac_volume_max = 127,
	.function_flags = OXYGEN_FUNCTION_2WIRE,
	.dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
	.adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
C
Clemens Ladisch 已提交
876 877
};

878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
static const struct oxygen_model model_xonar_hdav = {
	.longname = "Asus Virtuoso 200",
	.chip = "AV200",
	.owner = THIS_MODULE,
	.probe = xonar_model_probe,
	.init = xonar_hdav_init,
	.cleanup = xonar_hdav_cleanup,
	.suspend = xonar_hdav_suspend,
	.resume = xonar_hdav_resume,
	.pcm_hardware_filter = xonar_hdav_pcm_hardware_filter,
	.set_dac_params = set_hdav_params,
	.set_adc_params = set_cs53x1_params,
	.update_dac_volume = update_pcm1796_volume,
	.update_dac_mute = update_pcm1796_mute,
	.uart_input = xonar_hdav_uart_input,
	.ac97_switch = xonar_line_mic_ac97_switch,
	.dac_tlv = pcm1796_db_scale,
	.model_data_size = sizeof(struct xonar_data),
	.device_config = PLAYBACK_0_TO_I2S |
			 PLAYBACK_1_TO_SPDIF |
			 CAPTURE_0_FROM_I2S_2,
	.dac_channels = 8,
	.dac_volume_min = 0x0f,
	.dac_volume_max = 0xff,
902
	.misc_flags = OXYGEN_MISC_MIDI,
903 904 905 906 907
	.function_flags = OXYGEN_FUNCTION_2WIRE,
	.dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
	.adc_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
};

C
Clemens Ladisch 已提交
908 909 910
static int __devinit xonar_probe(struct pci_dev *pci,
				 const struct pci_device_id *pci_id)
{
911 912 913 914 915
	static const struct oxygen_model *const models[] = {
		[MODEL_D1]	= &model_xonar_d1,
		[MODEL_DX]	= &model_xonar_d1,
		[MODEL_D2]	= &model_xonar_d2,
		[MODEL_D2X]	= &model_xonar_d2,
916
		[MODEL_HDAV]	= &model_xonar_hdav,
917
	};
C
Clemens Ladisch 已提交
918 919 920 921 922 923 924 925 926
	static int dev;
	int err;

	if (dev >= SNDRV_CARDS)
		return -ENODEV;
	if (!enable[dev]) {
		++dev;
		return -ENOENT;
	}
927
	BUG_ON(pci_id->driver_data >= ARRAY_SIZE(models));
928
	err = oxygen_pci_probe(pci, index[dev], id[dev],
929 930
			       models[pci_id->driver_data],
			       pci_id->driver_data);
C
Clemens Ladisch 已提交
931 932 933 934 935 936 937 938 939 940
	if (err >= 0)
		++dev;
	return err;
}

static struct pci_driver xonar_driver = {
	.name = "AV200",
	.id_table = xonar_ids,
	.probe = xonar_probe,
	.remove = __devexit_p(oxygen_pci_remove),
C
Clemens Ladisch 已提交
941 942 943 944
#ifdef CONFIG_PM
	.suspend = oxygen_pci_suspend,
	.resume = oxygen_pci_resume,
#endif
C
Clemens Ladisch 已提交
945 946 947 948 949 950 951 952 953 954 955 956 957 958
};

static int __init alsa_card_xonar_init(void)
{
	return pci_register_driver(&xonar_driver);
}

static void __exit alsa_card_xonar_exit(void)
{
	pci_unregister_driver(&xonar_driver);
}

module_init(alsa_card_xonar_init)
module_exit(alsa_card_xonar_exit)