virtuoso.c 18.0 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
 */

C
Clemens Ladisch 已提交
65 66
#include <linux/pci.h>
#include <linux/delay.h>
67 68
#include <linux/mutex.h>
#include <sound/ac97_codec.h>
C
Clemens Ladisch 已提交
69 70 71 72 73 74
#include <sound/control.h>
#include <sound/core.h>
#include <sound/initval.h>
#include <sound/pcm.h>
#include <sound/tlv.h>
#include "oxygen.h"
75
#include "cm9780.h"
76
#include "pcm1796.h"
77 78
#include "cs4398.h"
#include "cs4362a.h"
C
Clemens Ladisch 已提交
79 80

MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
81
MODULE_DESCRIPTION("Asus AVx00 driver");
82
MODULE_LICENSE("GPL v2");
83
MODULE_SUPPORTED_DEVICE("{{Asus,AV100},{Asus,AV200}}");
C
Clemens Ladisch 已提交
84 85 86 87 88 89 90 91 92 93 94 95

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");

96 97 98
enum {
	MODEL_D2,
	MODEL_D2X,
99
	MODEL_D1,
100
	MODEL_DX,
101 102
};

C
Clemens Ladisch 已提交
103
static struct pci_device_id xonar_ids[] __devinitdata = {
104
	{ OXYGEN_PCI_SUBID(0x1043, 0x8269), .driver_data = MODEL_D2 },
105
	{ OXYGEN_PCI_SUBID(0x1043, 0x8275), .driver_data = MODEL_DX },
106
	{ OXYGEN_PCI_SUBID(0x1043, 0x82b7), .driver_data = MODEL_D2X },
107
	{ OXYGEN_PCI_SUBID(0x1043, 0x834f), .driver_data = MODEL_D1 },
C
Clemens Ladisch 已提交
108 109 110 111
	{ }
};
MODULE_DEVICE_TABLE(pci, xonar_ids);

112

113 114 115 116 117
#define GPIO_CS53x1_M_MASK	0x000c
#define GPIO_CS53x1_M_SINGLE	0x0000
#define GPIO_CS53x1_M_DOUBLE	0x0004
#define GPIO_CS53x1_M_QUAD	0x0008

118 119 120
#define GPIO_D2X_EXT_POWER	0x0020
#define GPIO_D2_ALT		0x0080
#define GPIO_D2_OUTPUT_ENABLE	0x0100
121

122 123
#define GPI_DX_EXT_POWER	0x01
#define GPIO_DX_OUTPUT_ENABLE	0x0001
124
#define GPIO_DX_FRONT_PANEL	0x0002
125
#define GPIO_DX_INPUT_ROUTE	0x0100
126 127 128 129

#define I2C_DEVICE_CS4398	0x9e	/* 10011, AD1=1, AD0=1, /W=0 */
#define I2C_DEVICE_CS4362A	0x30	/* 001100, AD0=0, /W=0 */

130
struct xonar_data {
131
	unsigned int model;
132 133 134 135 136
	unsigned int anti_pop_delay;
	u16 output_enable_bit;
	u8 ext_power_reg;
	u8 ext_power_int_reg;
	u8 ext_power_bit;
137
	u8 has_power;
138 139 140
	u8 pcm1796_oversampling;
	u8 cs4398_fm;
	u8 cs4362a_fm;
141 142
};

143 144
static void xonar_gpio_changed(struct oxygen *chip);

C
Clemens Ladisch 已提交
145 146 147 148 149
static void pcm1796_write(struct oxygen *chip, unsigned int codec,
			  u8 reg, u8 value)
{
	/* maps ALSA channel pair number to SPI output */
	static const u8 codec_map[4] = {
150
		0, 1, 2, 4
C
Clemens Ladisch 已提交
151
	};
152
	oxygen_write_spi(chip, OXYGEN_SPI_TRIGGER  |
C
Clemens Ladisch 已提交
153
			 OXYGEN_SPI_DATA_LENGTH_2 |
154
			 OXYGEN_SPI_CLOCK_160 |
C
Clemens Ladisch 已提交
155
			 (codec_map[codec] << OXYGEN_SPI_CODEC_SHIFT) |
156
			 OXYGEN_SPI_CEN_LATCH_CLOCK_HI,
C
Clemens Ladisch 已提交
157 158 159
			 (reg << 8) | value);
}

160 161 162 163 164 165 166 167 168 169
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);
}

170 171 172 173 174 175 176 177
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);
}

178 179 180 181 182 183 184 185
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;
186
		chip->model.gpio_changed = xonar_gpio_changed;
187 188 189
		data->has_power = !!(oxygen_read8(chip, data->ext_power_reg)
				     & data->ext_power_bit);
	}
190 191
	oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
			  GPIO_CS53x1_M_MASK | data->output_enable_bit);
192 193 194
	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);
195
	xonar_enable_output(chip);
196 197
}

198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
static void update_pcm1796_volume(struct oxygen *chip)
{
	unsigned int i;

	for (i = 0; i < 4; ++i) {
		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)
{
	unsigned int i;
	u8 value;

	value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_LJUST | PCM1796_ATLD;
	if (chip->dac_mute)
		value |= PCM1796_MUTE;
	for (i = 0; i < 4; ++i)
		pcm1796_write(chip, i, 18, value);
}

220
static void pcm1796_init(struct oxygen *chip)
C
Clemens Ladisch 已提交
221
{
222
	struct xonar_data *data = chip->model_data;
C
Clemens Ladisch 已提交
223 224 225
	unsigned int i;

	for (i = 0; i < 4; ++i) {
226
		pcm1796_write(chip, i, 19, PCM1796_FLT_SHARP | PCM1796_ATS_1);
227
		pcm1796_write(chip, i, 20, data->pcm1796_oversampling);
228
		pcm1796_write(chip, i, 21, 0);
C
Clemens Ladisch 已提交
229
	}
230 231
	update_pcm1796_mute(chip); /* set ATLD before ATL/ATR */
	update_pcm1796_volume(chip);
232 233 234 235 236 237 238 239 240
}

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;
241 242 243 244 245 246 247
	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);
	}
248 249

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

251 252 253 254
	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 已提交
255 256 257 258 259

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

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
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);
}

291
static void cs43xx_init(struct oxygen *chip)
292 293 294 295 296 297 298
{
	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 */
299
	cs4398_write(chip, 2, data->cs4398_fm);
300 301 302 303 304 305 306 307
	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);
308 309 310
	cs4362a_write(chip, 0x06, data->cs4362a_fm);
	cs4362a_write(chip, 0x09, data->cs4362a_fm);
	cs4362a_write(chip, 0x0c, data->cs4362a_fm);
311 312
	update_cs43xx_volume(chip);
	update_cs43xx_mute(chip);
313 314 315
	/* clear power down */
	cs4398_write(chip, 8, CS4398_CPEN);
	cs4362a_write(chip, 0x01, CS4362A_CPEN);
316 317
}

318
static void xonar_d1_init(struct oxygen *chip)
319 320 321 322 323 324 325 326
{
	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;
327 328 329 330 331
	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;
	}
332 333 334 335 336 337 338

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

	cs43xx_init(chip);
339 340

	oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL,
341 342 343
			  GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE);
	oxygen_clear_bits16(chip, OXYGEN_GPIO_DATA,
			    GPIO_DX_FRONT_PANEL | GPIO_DX_INPUT_ROUTE);
344 345 346 347 348 349 350 351

	xonar_common_init(chip);

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

352
static void xonar_disable_output(struct oxygen *chip)
C
Clemens Ladisch 已提交
353
{
354 355 356
	struct xonar_data *data = chip->model_data;

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

359 360 361 362 363
static void xonar_d2_cleanup(struct oxygen *chip)
{
	xonar_disable_output(chip);
}

364
static void xonar_d1_cleanup(struct oxygen *chip)
365
{
366
	xonar_disable_output(chip);
367 368 369 370
	cs4362a_write(chip, 0x01, CS4362A_PDN | CS4362A_CPEN);
	oxygen_clear_bits8(chip, OXYGEN_FUNCTION, OXYGEN_FUNCTION_RESET_CODEC);
}

371 372 373 374 375 376 377 378 379 380
static void xonar_d2_suspend(struct oxygen *chip)
{
	xonar_d2_cleanup(chip);
}

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

C
Clemens Ladisch 已提交
381 382 383 384 385 386
static void xonar_d2_resume(struct oxygen *chip)
{
	pcm1796_init(chip);
	xonar_enable_output(chip);
}

387
static void xonar_d1_resume(struct oxygen *chip)
C
Clemens Ladisch 已提交
388 389 390 391 392
{
	cs43xx_init(chip);
	xonar_enable_output(chip);
}

C
Clemens Ladisch 已提交
393 394 395
static void set_pcm1796_params(struct oxygen *chip,
			       struct snd_pcm_hw_params *params)
{
396
	struct xonar_data *data = chip->model_data;
C
Clemens Ladisch 已提交
397 398
	unsigned int i;

399 400
	data->pcm1796_oversampling =
		params_rate(params) >= 96000 ? PCM1796_OS_32 : PCM1796_OS_64;
C
Clemens Ladisch 已提交
401
	for (i = 0; i < 4; ++i)
402
		pcm1796_write(chip, i, 20, data->pcm1796_oversampling);
C
Clemens Ladisch 已提交
403 404
}

405
static void set_cs53x1_params(struct oxygen *chip,
C
Clemens Ladisch 已提交
406 407 408 409 410
			      struct snd_pcm_hw_params *params)
{
	unsigned int value;

	if (params_rate(params) <= 54000)
411
		value = GPIO_CS53x1_M_SINGLE;
C
Clemens Ladisch 已提交
412
	else if (params_rate(params) <= 108000)
413
		value = GPIO_CS53x1_M_DOUBLE;
C
Clemens Ladisch 已提交
414
	else
415
		value = GPIO_CS53x1_M_QUAD;
416
	oxygen_write16_masked(chip, OXYGEN_GPIO_DATA,
417
			      value, GPIO_CS53x1_M_MASK);
C
Clemens Ladisch 已提交
418 419
}

420 421 422
static void set_cs43xx_params(struct oxygen *chip,
			      struct snd_pcm_hw_params *params)
{
423
	struct xonar_data *data = chip->model_data;
424

425 426
	data->cs4398_fm = CS4398_DEM_NONE | CS4398_DIF_LJUST;
	data->cs4362a_fm = CS4362A_ATAPI_B_R | CS4362A_ATAPI_A_L;
427
	if (params_rate(params) <= 50000) {
428 429
		data->cs4398_fm |= CS4398_FM_SINGLE;
		data->cs4362a_fm |= CS4362A_FM_SINGLE;
430
	} else if (params_rate(params) <= 100000) {
431 432
		data->cs4398_fm |= CS4398_FM_DOUBLE;
		data->cs4362a_fm |= CS4362A_FM_DOUBLE;
433
	} else {
434 435
		data->cs4398_fm |= CS4398_FM_QUAD;
		data->cs4362a_fm |= CS4362A_FM_QUAD;
436
	}
437 438 439 440
	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);
441 442
}

443 444 445 446 447
static void xonar_gpio_changed(struct oxygen *chip)
{
	struct xonar_data *data = chip->model_data;
	u8 has_power;

448 449
	has_power = !!(oxygen_read8(chip, data->ext_power_reg)
		       & data->ext_power_bit);
450 451 452 453 454 455 456 457 458 459 460 461
	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 */
		}
	}
}

462 463
static int gpio_bit_switch_get(struct snd_kcontrol *ctl,
			       struct snd_ctl_elem_value *value)
C
Clemens Ladisch 已提交
464 465
{
	struct oxygen *chip = ctl->private_data;
466
	u16 bit = ctl->private_value;
C
Clemens Ladisch 已提交
467 468

	value->value.integer.value[0] =
469
		!!(oxygen_read16(chip, OXYGEN_GPIO_DATA) & bit);
C
Clemens Ladisch 已提交
470 471 472
	return 0;
}

473 474
static int gpio_bit_switch_put(struct snd_kcontrol *ctl,
			       struct snd_ctl_elem_value *value)
C
Clemens Ladisch 已提交
475 476
{
	struct oxygen *chip = ctl->private_data;
477
	u16 bit = ctl->private_value;
C
Clemens Ladisch 已提交
478 479 480 481 482 483
	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])
484
		new_bits = old_bits | bit;
C
Clemens Ladisch 已提交
485
	else
486
		new_bits = old_bits & ~bit;
C
Clemens Ladisch 已提交
487 488 489 490 491 492 493 494 495 496 497
	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,
498 499 500
	.get = gpio_bit_switch_get,
	.put = gpio_bit_switch_put,
	.private_value = GPIO_D2_ALT,
C
Clemens Ladisch 已提交
501 502
};

503
static const struct snd_kcontrol_new front_panel_switch = {
504
	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
505 506
	.name = "Front Panel Switch",
	.info = snd_ctl_boolean_mono_info,
507 508 509
	.get = gpio_bit_switch_get,
	.put = gpio_bit_switch_put,
	.private_value = GPIO_DX_FRONT_PANEL,
510 511
};

512
static void xonar_d1_ac97_switch(struct oxygen *chip,
513 514 515 516 517 518 519 520 521 522 523
				 unsigned int reg, unsigned int mute)
{
	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 已提交
524
static const DECLARE_TLV_DB_SCALE(pcm1796_db_scale, -12000, 50, 0);
525
static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -12700, 100, 0);
C
Clemens Ladisch 已提交
526

527
static int xonar_d2_control_filter(struct snd_kcontrol_new *template)
528
{
529
	if (!strncmp(template->name, "CD Capture ", 11))
530
		/* CD in is actually connected to the video in pin */
531 532 533 534
		template->private_value ^= AC97_CD ^ AC97_VIDEO;
	return 0;
}

535
static int xonar_d1_control_filter(struct snd_kcontrol_new *template)
536
{
537
	if (!strncmp(template->name, "CD Capture ", 11))
538 539 540 541
		return 1; /* no CD input */
	return 0;
}

542
static int xonar_d2_mixer_init(struct oxygen *chip)
C
Clemens Ladisch 已提交
543 544 545 546
{
	return snd_ctl_add(chip->card, snd_ctl_new1(&alt_switch, chip));
}

547
static int xonar_d1_mixer_init(struct oxygen *chip)
548
{
549
	return snd_ctl_add(chip->card, snd_ctl_new1(&front_panel_switch, chip));
550 551
}

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574
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",
	};
	struct xonar_data *data = chip->model_data;

	data->model = driver_data;
	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,
575 576
	.cleanup = xonar_d2_cleanup,
	.suspend = xonar_d2_suspend,
577 578 579 580 581 582 583
	.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),
584 585 586
	.device_config = PLAYBACK_0_TO_I2S |
			 PLAYBACK_1_TO_SPDIF |
			 CAPTURE_0_FROM_I2S_2 |
587 588 589
			 CAPTURE_1_FROM_SPDIF |
			 MIDI_OUTPUT |
			 MIDI_INPUT,
590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
	.dac_channels = 8,
	.dac_volume_min = 0x0f,
	.dac_volume_max = 0xff,
	.misc_flags = OXYGEN_MISC_MIDI,
	.function_flags = OXYGEN_FUNCTION_SPI |
			  OXYGEN_FUNCTION_ENABLE_SPI_4_5,
	.dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
	.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,
609
	.suspend = xonar_d1_suspend,
610 611 612 613 614 615 616 617
	.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,
	.ac97_switch = xonar_d1_ac97_switch,
	.dac_tlv = cs4362a_db_scale,
	.model_data_size = sizeof(struct xonar_data),
618 619 620
	.device_config = PLAYBACK_0_TO_I2S |
			 PLAYBACK_1_TO_SPDIF |
			 CAPTURE_0_FROM_I2S_2,
621 622 623 624 625 626
	.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 已提交
627 628 629 630 631
};

static int __devinit xonar_probe(struct pci_dev *pci,
				 const struct pci_device_id *pci_id)
{
632 633 634 635 636 637
	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,
	};
C
Clemens Ladisch 已提交
638 639 640 641 642 643 644 645 646
	static int dev;
	int err;

	if (dev >= SNDRV_CARDS)
		return -ENODEV;
	if (!enable[dev]) {
		++dev;
		return -ENOENT;
	}
647
	BUG_ON(pci_id->driver_data >= ARRAY_SIZE(models));
648
	err = oxygen_pci_probe(pci, index[dev], id[dev],
649 650
			       models[pci_id->driver_data],
			       pci_id->driver_data);
C
Clemens Ladisch 已提交
651 652 653 654 655 656 657 658 659 660
	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 已提交
661 662 663 664
#ifdef CONFIG_PM
	.suspend = oxygen_pci_suspend,
	.resume = oxygen_pci_resume,
#endif
C
Clemens Ladisch 已提交
665 666 667 668 669 670 671 672 673 674 675 676 677 678
};

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)