Commit 77b0b254 authored by Ondrej Zary's avatar Ondrej Zary Committed by Takashi Iwai
Browse files

ALSA: ice1712: Add Philips PSC724 Ultimate Edge 



Add psc724 subdriver to snd-ice1712 that provides full support for
Philips PSC724 Ultimate Edge sound cards.

Signed-off-by: default avatarOndrej Zary <linux@rainbow-software.org>
Signed-off-by: default avatarTakashi Iwai <tiwai@suse.de>
parent bfe51427

sound/pci/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -630,7 +630,7 @@ config SND_ICE1724 
	  AudioTrak Prodigy 192, 7.1 (HIFI/LT/XT), HD2; Hercules

	  Fortissimo IV; ESI Juli@; Pontis MS300; EGO-SYS WaveTerminal

	  192M; Albatron K8X800 Pro II; Chaintech ZNF3-150/250, 9CJS,

	  AV-710; Shuttle SN25P.

	  AV-710; Shuttle SN25P; Philips PSC724 Ultimate Edge.



	  To compile this driver as a module, choose M here: the module

	  will be called snd-ice1724.

sound/pci/ice1712/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ 


snd-ice17xx-ak4xxx-objs := ak4xxx.o

snd-ice1712-objs := ice1712.o delta.o hoontech.o ews.o

snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o prodigy_hifi.o juli.o phase.o wtm.o se.o maya44.o quartet.o

snd-ice1724-objs := ice1724.o amp.o revo.o aureon.o vt1720_mobo.o pontis.o prodigy192.o prodigy_hifi.o juli.o phase.o wtm.o se.o maya44.o quartet.o psc724.o wm8766.o wm8776.o



# Toplevel Module Dependency

obj-$(CONFIG_SND_ICE1712) += snd-ice1712.o snd-ice17xx-ak4xxx.o

sound/pci/ice1712/ice1724.c

+3 −1
Original line number Diff line number Diff line
@@ -54,6 +54,7 @@ 
#include "wtm.h"

#include "se.h"

#include "quartet.h"

#include "psc724.h"



MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");

MODULE_DESCRIPTION("VIA ICEnsemble ICE1724/1720 (Envy24HT/PT)");
@@ -2257,6 +2258,7 @@ static struct snd_ice1712_card_info *card_tables[] __devinitdata = { 
	snd_vt1724_se_cards,

	snd_vt1724_qtet_cards,

	snd_vt1724_ooaoo_cards,

	snd_vt1724_psc724_cards,

	NULL,

};
@@ -2372,7 +2374,7 @@ static int __devinit snd_vt1724_read_eeprom(struct snd_ice1712 *ice, 
		return -EIO;

	}

	ice->eeprom.version = snd_vt1724_read_i2c(ice, dev, 0x05);

	if (ice->eeprom.version != 2)

	if (ice->eeprom.version != 1 && ice->eeprom.version != 2)

		printk(KERN_WARNING "ice1724: Invalid EEPROM version %i\n",

		       ice->eeprom.version);

	size = ice->eeprom.size - 6;

sound/pci/ice1712/psc724.c

0 → 100644
+464 −0
Original line number Diff line number Diff line 
/*

 *   ALSA driver for ICEnsemble VT1724 (Envy24HT)

 *

 *   Lowlevel functions for Philips PSC724 Ultimate Edge

 *

 *	Copyright (c) 2012 Ondrej Zary <linux@rainbow-software.org>

 *

 *   This program is free software; you can redistribute it and/or modify

 *   it under the terms of the GNU General Public License as published by

 *   the Free Software Foundation; either version 2 of the License, or

 *   (at your option) any later version.

 *

 *   This program 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 program; if not, write to the Free Software

 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA

 *

 */



#include <linux/delay.h>

#include <linux/init.h>

#include <linux/slab.h>

#include <sound/core.h>



#include "ice1712.h"

#include "envy24ht.h"

#include "psc724.h"

#include "wm8766.h"

#include "wm8776.h"



struct psc724_spec {

	struct snd_wm8766 wm8766;

	struct snd_wm8776 wm8776;

	bool mute_all, jack_detect;

	struct snd_ice1712 *ice;

	struct delayed_work hp_work;

	bool hp_connected;

};



/****************************************************************************/

/*  PHILIPS PSC724 ULTIMATE EDGE                                            */

/****************************************************************************/

/*

 *  VT1722 (Envy24GT) - 6 outputs, 4 inputs (only 2 used), 24-bit/96kHz

 *

 *  system configuration ICE_EEP2_SYSCONF=0x42

 *    XIN1 49.152MHz

 *    no MPU401

 *    one stereo ADC, no S/PDIF receiver

 *    three stereo DACs (FRONT, REAR, CENTER+LFE)

 *

 *  AC-Link configuration ICE_EEP2_ACLINK=0x80

 *    use I2S, not AC97

 *

 *  I2S converters feature ICE_EEP2_I2S=0x30

 *    I2S codec has no volume/mute control feature (bug!)

 *    I2S codec does not support 96KHz or 192KHz (bug!)

 *    I2S codec 24bits

 *

 *  S/PDIF configuration ICE_EEP2_SPDIF=0xc1

 *    Enable integrated S/PDIF transmitter

 *    internal S/PDIF out implemented

 *    No S/PDIF input

 *    External S/PDIF out implemented

 *

 *

 * ** connected chips **

 *

 *  WM8776

 *     2-channel DAC used for main output and stereo ADC (with 10-channel MUX)

 *     AIN1: LINE IN, AIN2: CD/VIDEO, AIN3: AUX, AIN4: Front MIC, AIN5: Rear MIC

 *     Controlled by I2C using VT1722 I2C interface:

 *          MODE (pin16) -- GND

 *          CE   (pin17) -- GND  I2C mode (address=0x34)

 *          DI   (pin18) -- SDA  (VT1722 pin70)

 *          CL   (pin19) -- SCLK (VT1722 pin71)

 *

 *  WM8766

 *      6-channel DAC used for rear & center/LFE outputs (only 4 channels used)

 *      Controlled by SPI using VT1722 GPIO pins:

 *          MODE   (pin 1) -- GPIO19 (VT1722 pin99)

 *          ML/I2S (pin11) -- GPIO18 (VT1722 pin98)

 *          MC/IWL (pin12) -- GPIO17 (VT1722 pin97)

 *          MD/DM  (pin13) -- GPIO16 (VT1722 pin96)

 *          MUTE   (pin14) -- GPIO20 (VT1722 pin101)

 *

 *  GPIO14 is used as input for headphone jack detection (1 = connected)

 *  GPIO22 is used as MUTE ALL output, grounding all 6 channels

 *

 * ** output pins and device names **

 *

 *   5.1ch name -- output connector color -- device (-D option)

 *

 *      FRONT 2ch                  -- green  -- plughw:0,0

 *      CENTER(Lch) SUBWOOFER(Rch) -- orange -- plughw:0,2,0

 *      REAR 2ch                   -- black  -- plughw:0,2,1

 */



/* codec access low-level functions */



#define GPIO_HP_JACK	(1 << 14)

#define GPIO_MUTE_SUR	(1 << 20)

#define GPIO_MUTE_ALL	(1 << 22)



#define JACK_INTERVAL	1000



#define PSC724_SPI_DELAY 1



#define PSC724_SPI_DATA	(1 << 16)

#define PSC724_SPI_CLK	(1 << 17)

#define PSC724_SPI_LOAD	(1 << 18)

#define PSC724_SPI_MASK	(PSC724_SPI_DATA | PSC724_SPI_CLK | PSC724_SPI_LOAD)



static void psc724_wm8766_write(struct snd_wm8766 *wm, u16 addr, u16 data)

{

	struct psc724_spec *spec = container_of(wm, struct psc724_spec, wm8766);

	struct snd_ice1712 *ice = spec->ice;

	u32 st, bits;

	int i;



	snd_ice1712_save_gpio_status(ice);



	st = ((addr & 0x7f) << 9) | (data & 0x1ff);

	snd_ice1712_gpio_set_dir(ice, ice->gpio.direction | PSC724_SPI_MASK);

	snd_ice1712_gpio_set_mask(ice, ice->gpio.write_mask & ~PSC724_SPI_MASK);

	bits = snd_ice1712_gpio_read(ice) & ~PSC724_SPI_MASK;

	snd_ice1712_gpio_write(ice, bits);



	for (i = 0; i < 16; i++) {

		udelay(PSC724_SPI_DELAY);

		bits &= ~PSC724_SPI_CLK;

		/* MSB first */

		st <<= 1;

		if (st & 0x10000)

			bits |= PSC724_SPI_DATA;

		else

			bits &= ~PSC724_SPI_DATA;

		snd_ice1712_gpio_write(ice, bits);

		/* CLOCK high */

		udelay(PSC724_SPI_DELAY);

		bits |= PSC724_SPI_CLK;

		snd_ice1712_gpio_write(ice, bits);

	}

	/* LOAD high */

	udelay(PSC724_SPI_DELAY);

	bits |= PSC724_SPI_LOAD;

	snd_ice1712_gpio_write(ice, bits);

	/* LOAD low, DATA and CLOCK high */

	udelay(PSC724_SPI_DELAY);

	bits |= (PSC724_SPI_DATA | PSC724_SPI_CLK);

	snd_ice1712_gpio_write(ice, bits);



	snd_ice1712_restore_gpio_status(ice);

}



static void psc724_wm8776_write(struct snd_wm8776 *wm, u8 addr, u8 data)

{

	struct psc724_spec *spec = container_of(wm, struct psc724_spec, wm8776);



	snd_vt1724_write_i2c(spec->ice, 0x34, addr, data);

}



/* mute all */



static void psc724_set_master_switch(struct snd_ice1712 *ice, bool on)

{

	unsigned int bits = snd_ice1712_gpio_read(ice);

	struct psc724_spec *spec = ice->spec;



	spec->mute_all = !on;

	if (on)

		bits &= ~(GPIO_MUTE_ALL | GPIO_MUTE_SUR);

	else

		bits |= GPIO_MUTE_ALL | GPIO_MUTE_SUR;

	snd_ice1712_gpio_write(ice, bits);

}



static bool psc724_get_master_switch(struct snd_ice1712 *ice)

{

	struct psc724_spec *spec = ice->spec;



	return !spec->mute_all;

}



/* jack detection */



static void psc724_set_jack_state(struct snd_ice1712 *ice, bool hp_connected)

{

	struct psc724_spec *spec = ice->spec;

	struct snd_ctl_elem_id elem_id;

	struct snd_kcontrol *kctl;

	u16 power = spec->wm8776.regs[WM8776_REG_PWRDOWN] & ~WM8776_PWR_HPPD;



	psc724_set_master_switch(ice, !hp_connected);

	if (!hp_connected)

		power |= WM8776_PWR_HPPD;

	snd_wm8776_set_power(&spec->wm8776, power);

	spec->hp_connected = hp_connected;

	/* notify about master speaker mute change */

	memset(&elem_id, 0, sizeof(elem_id));

	elem_id.iface = SNDRV_CTL_ELEM_IFACE_MIXER;

	strncpy(elem_id.name, "Master Speakers Playback Switch",

						sizeof(elem_id.name));

	kctl = snd_ctl_find_id(ice->card, &elem_id);

	snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);

	/* and headphone mute change */

	strncpy(elem_id.name, spec->wm8776.ctl[WM8776_CTL_HP_SW].name,

						sizeof(elem_id.name));

	kctl = snd_ctl_find_id(ice->card, &elem_id);

	snd_ctl_notify(ice->card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);

}



static void psc724_update_hp_jack_state(struct work_struct *work)

{

	struct psc724_spec *spec = container_of(work, struct psc724_spec,

						hp_work.work);

	struct snd_ice1712 *ice = spec->ice;

	bool hp_connected = snd_ice1712_gpio_read(ice) & GPIO_HP_JACK;



	schedule_delayed_work(&spec->hp_work, msecs_to_jiffies(JACK_INTERVAL));

	if (hp_connected == spec->hp_connected)

		return;

	psc724_set_jack_state(ice, hp_connected);

}



static void psc724_set_jack_detection(struct snd_ice1712 *ice, bool on)

{

	struct psc724_spec *spec = ice->spec;



	if (spec->jack_detect == on)

		return;



	spec->jack_detect = on;

	if (on) {

		bool hp_connected = snd_ice1712_gpio_read(ice) & GPIO_HP_JACK;

		psc724_set_jack_state(ice, hp_connected);

		schedule_delayed_work(&spec->hp_work,

					msecs_to_jiffies(JACK_INTERVAL));

	} else

		cancel_delayed_work_sync(&spec->hp_work);

}



static bool psc724_get_jack_detection(struct snd_ice1712 *ice)

{

	struct psc724_spec *spec = ice->spec;



	return spec->jack_detect;

}



/* mixer controls */



struct psc724_control {

	char *name;

	void (*set)(struct snd_ice1712 *ice, bool on);

	bool (*get)(struct snd_ice1712 *ice);

};



static const struct psc724_control psc724_cont[] = {

	{

		.name = "Master Speakers Playback Switch",

		.set = psc724_set_master_switch,

		.get = psc724_get_master_switch,

	},

	{

		.name = "Headphone Jack Detection Playback Switch",

		.set = psc724_set_jack_detection,

		.get = psc724_get_jack_detection,

	},

};



static int psc724_ctl_get(struct snd_kcontrol *kcontrol,

				  struct snd_ctl_elem_value *ucontrol)

{

	struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);

	int n = kcontrol->private_value;



	ucontrol->value.integer.value[0] = psc724_cont[n].get(ice);



	return 0;

}



static int psc724_ctl_put(struct snd_kcontrol *kcontrol,

				  struct snd_ctl_elem_value *ucontrol)

{

	struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);

	int n = kcontrol->private_value;



	psc724_cont[n].set(ice, ucontrol->value.integer.value[0]);



	return 0;

}



static char *front_volume	= "Front Playback Volume";

static char *front_switch	= "Front Playback Switch";

static char *front_zc		= "Front Zero Cross Detect Playback Switch";

static char *front_izd		= "Front Infinite Zero Detect Playback Switch";

static char *front_phase	= "Front Phase Invert Playback Switch";

static char *front_deemph	= "Front Deemphasis Playback Switch";

static char *ain1_switch	= "Line Capture Switch";

static char *ain2_switch	= "CD Capture Switch";

static char *ain3_switch	= "AUX Capture Switch";

static char *ain4_switch	= "Front Mic Capture Switch";

static char *ain5_switch	= "Rear Mic Capture Switch";

static char *rear_volume	= "Surround Playback Volume";

static char *clfe_volume	= "CLFE Playback Volume";

static char *rear_switch	= "Surround Playback Switch";

static char *clfe_switch	= "CLFE Playback Switch";

static char *rear_phase		= "Surround Phase Invert Playback Switch";

static char *clfe_phase		= "CLFE Phase Invert Playback Switch";

static char *rear_deemph	= "Surround Deemphasis Playback Switch";

static char *clfe_deemph	= "CLFE Deemphasis Playback Switch";

static char *rear_clfe_izd	= "Rear Infinite Zero Detect Playback Switch";

static char *rear_clfe_zc	= "Rear Zero Cross Detect Playback Switch";



static int __devinit psc724_add_controls(struct snd_ice1712 *ice)

{

	struct snd_kcontrol_new cont;

	struct snd_kcontrol *ctl;

	int err, i;

	struct psc724_spec *spec = ice->spec;



	spec->wm8776.ctl[WM8776_CTL_DAC_VOL].name = front_volume;

	spec->wm8776.ctl[WM8776_CTL_DAC_SW].name = front_switch;

	spec->wm8776.ctl[WM8776_CTL_DAC_ZC_SW].name = front_zc;

	spec->wm8776.ctl[WM8776_CTL_AUX_SW].name = NULL;

	spec->wm8776.ctl[WM8776_CTL_DAC_IZD_SW].name = front_izd;

	spec->wm8776.ctl[WM8776_CTL_PHASE_SW].name = front_phase;

	spec->wm8776.ctl[WM8776_CTL_DEEMPH_SW].name = front_deemph;

	spec->wm8776.ctl[WM8776_CTL_INPUT1_SW].name = ain1_switch;

	spec->wm8776.ctl[WM8776_CTL_INPUT2_SW].name = ain2_switch;

	spec->wm8776.ctl[WM8776_CTL_INPUT3_SW].name = ain3_switch;

	spec->wm8776.ctl[WM8776_CTL_INPUT4_SW].name = ain4_switch;

	spec->wm8776.ctl[WM8776_CTL_INPUT5_SW].name = ain5_switch;

	snd_wm8776_build_controls(&spec->wm8776);

	spec->wm8766.ctl[WM8766_CTL_CH1_VOL].name = rear_volume;

	spec->wm8766.ctl[WM8766_CTL_CH2_VOL].name = clfe_volume;

	spec->wm8766.ctl[WM8766_CTL_CH3_VOL].name = NULL;

	spec->wm8766.ctl[WM8766_CTL_CH1_SW].name = rear_switch;

	spec->wm8766.ctl[WM8766_CTL_CH2_SW].name = clfe_switch;

	spec->wm8766.ctl[WM8766_CTL_CH3_SW].name = NULL;

	spec->wm8766.ctl[WM8766_CTL_PHASE1_SW].name = rear_phase;

	spec->wm8766.ctl[WM8766_CTL_PHASE2_SW].name = clfe_phase;

	spec->wm8766.ctl[WM8766_CTL_PHASE3_SW].name = NULL;

	spec->wm8766.ctl[WM8766_CTL_DEEMPH1_SW].name = rear_deemph;

	spec->wm8766.ctl[WM8766_CTL_DEEMPH2_SW].name = clfe_deemph;

	spec->wm8766.ctl[WM8766_CTL_DEEMPH3_SW].name = NULL;

	spec->wm8766.ctl[WM8766_CTL_IZD_SW].name = rear_clfe_izd;

	spec->wm8766.ctl[WM8766_CTL_ZC_SW].name = rear_clfe_zc;

	snd_wm8766_build_controls(&spec->wm8766);



	memset(&cont, 0, sizeof(cont));

	cont.iface = SNDRV_CTL_ELEM_IFACE_MIXER;

	for (i = 0; i < ARRAY_SIZE(psc724_cont); i++) {

		cont.private_value = i;

		cont.name = psc724_cont[i].name;

		cont.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;

		cont.info = snd_ctl_boolean_mono_info;

		cont.get = psc724_ctl_get;

		cont.put = psc724_ctl_put;

		ctl = snd_ctl_new1(&cont, ice);

		if (!ctl)

			return -ENOMEM;

		err = snd_ctl_add(ice->card, ctl);

		if (err < 0)

			return err;

	}



	return 0;

}



static void psc724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate)

{

	struct psc724_spec *spec = ice->spec;

	/* restore codec volume settings after rate change (PMCLK stop) */

	snd_wm8776_volume_restore(&spec->wm8776);

	snd_wm8766_volume_restore(&spec->wm8766);

}



/* power management */



#ifdef CONFIG_PM

static int psc724_resume(struct snd_ice1712 *ice)

{

	struct psc724_spec *spec = ice->spec;



	snd_wm8776_resume(&spec->wm8776);

	snd_wm8766_resume(&spec->wm8766);



	return 0;

}

#endif



/* init */



static int __devinit psc724_init(struct snd_ice1712 *ice)

{

	struct psc724_spec *spec;



	spec = kzalloc(sizeof(*spec), GFP_KERNEL);

	if (!spec)

		return -ENOMEM;

	ice->spec = spec;

	spec->ice = ice;



	ice->num_total_dacs = 6;

	ice->num_total_adcs = 2;

	spec->wm8776.ops.write = psc724_wm8776_write;

	spec->wm8776.card = ice->card;

	snd_wm8776_init(&spec->wm8776);

	spec->wm8766.ops.write = psc724_wm8766_write;

	spec->wm8766.card = ice->card;

#ifdef CONFIG_PM

	ice->pm_resume = psc724_resume;

	ice->pm_suspend_enabled = 1;

#endif

	snd_wm8766_init(&spec->wm8766);

	snd_wm8766_set_if(&spec->wm8766,

			WM8766_IF_FMT_I2S | WM8766_IF_IWL_24BIT);

	ice->gpio.set_pro_rate = psc724_set_pro_rate;

	INIT_DELAYED_WORK(&spec->hp_work, psc724_update_hp_jack_state);

	psc724_set_jack_detection(ice, true);

	return 0;

}



static void psc724_exit(struct snd_ice1712 *ice)

{

	struct psc724_spec *spec = ice->spec;



	cancel_delayed_work_sync(&spec->hp_work);

}



/* PSC724 has buggy EEPROM (no 96&192kHz, all FFh GPIOs), so override it here */

static unsigned char psc724_eeprom[] __devinitdata = {

	[ICE_EEP2_SYSCONF]	= 0x42,	/* 49.152MHz, 1 ADC, 3 DACs */

	[ICE_EEP2_ACLINK]	= 0x80,	/* I2S */

	[ICE_EEP2_I2S]		= 0xf0,	/* I2S volume, 96kHz, 24bit */

	[ICE_EEP2_SPDIF]	= 0xc1,	/* spdif out-en, out-int, no input */

	/* GPIO outputs */

	[ICE_EEP2_GPIO_DIR2]	= 0x5f, /* MUTE_ALL,WM8766 MUTE/MODE/ML/MC/MD */

	/* GPIO write enable */

	[ICE_EEP2_GPIO_MASK]	= 0xff, /* read-only */

	[ICE_EEP2_GPIO_MASK1]	= 0xff, /* read-only */

	[ICE_EEP2_GPIO_MASK2]	= 0xa0, /* MUTE_ALL,WM8766 MUTE/MODE/ML/MC/MD */

	/* GPIO initial state */

	[ICE_EEP2_GPIO_STATE2]	= 0x20,	/* unmuted, all WM8766 pins low */

};



struct snd_ice1712_card_info snd_vt1724_psc724_cards[] __devinitdata = {

	{

		.subvendor = VT1724_SUBDEVICE_PSC724,

		.name = "Philips PSC724 Ultimate Edge",

		.model = "psc724",

		.chip_init = psc724_init,

		.chip_exit = psc724_exit,

		.build_controls = psc724_add_controls,

		.eeprom_size = sizeof(psc724_eeprom),

		.eeprom_data = psc724_eeprom,

	},

	{} /*terminator*/

};

sound/pci/ice1712/psc724.h

0 → 100644
+13 −0
Original line number Diff line number Diff line 
#ifndef __SOUND_PSC724_H

#define __SOUND_PSC724_H



/* ID */

#define PSC724_DEVICE_DESC	\

		"{Philips,PSC724 Ultimate Edge},"



#define VT1724_SUBDEVICE_PSC724		0xab170619



/* entry struct */

extern struct snd_ice1712_card_info snd_vt1724_psc724_cards[];



#endif /* __SOUND_PSC724_H */