Merge branch 'topic/maya44' into for-linus

			* Onkyo SE-90PCI

			* Onkyo SE-200PCI

			* ESI Juli@

			* ESI Maya44

			* Hercules Fortissimo IV

			* EGO-SYS WaveTerminal 192M

		  prodigy71xt, prodigy71hifi, prodigyhd2, prodigy192,

		  juli, aureon51, aureon71, universe, ap192, k8x800,

		  phase22, phase28, ms300, av710, se200pci, se90pci,

		  fortissimo4, sn25p, WT192M

		  fortissimo4, sn25p, WT192M, maya44

    This module supports multiple cards and autoprobe.

NOTE: The following is the original document of Rainer's patch that the

current maya44 code based on.  Some contents might be obsoleted, but I

keep here as reference -- tiwai

----------------------------------------------------------------

STATE OF DEVELOPMENT:

This driver is being developed on the initiative of Piotr Makowski (oponek@gmail.com) and financed by Lars Bergmann.

Development is carried out by Rainer Zimmermann (mail@lightshed.de).

ESI provided a sample Maya44 card for the development work.

However, unfortunately it has turned out difficult to get detailed programming information, so I (Rainer Zimmermann) had to find out some card-specific information by experiment and conjecture. Some information (in particular, several GPIO bits) is still missing.

This is the first testing version of the Maya44 driver released to the alsa-devel mailing list (Feb 5, 2008).

The following functions work, as tested by Rainer Zimmermann and Piotr Makowski:

- playback and capture at all sampling rates

- input/output level

- crossmixing

- line/mic switch

- phantom power switch

- analogue monitor a.k.a bypass

The following functions *should* work, but are not fully tested:

- Channel 3+4 analogue - S/PDIF input switching

- S/PDIF output

- all inputs/outputs on the M/IO/DIO extension card

- internal/external clock selection

*In particular, we would appreciate testing of these functions by anyone who has access to an M/IO/DIO extension card.*

Things that do not seem to work:

- The level meters ("multi track") in 'alsamixer' do not seem to react to signals in (if this is a bug, it would probably be in the existing ICE1724 code).

- Ardour 2.1 seems to work only via JACK, not using ALSA directly or via OSS. This still needs to be tracked down.

DRIVER DETAILS:

the following files were added:

pci/ice1724/maya44.c        - Maya44 specific code

pci/ice1724/maya44.h

pci/ice1724/ice1724.patch

pci/ice1724/ice1724.h.patch - PROPOSED patch to ice1724.h (see SAMPLING RATES)

i2c/other/wm8776.c  - low-level access routines for Wolfson WM8776 codecs 

include/wm8776.h

Note that the wm8776.c code is meant to be card-independent and does not actually register the codec with the ALSA infrastructure.

This is done in maya44.c, mainly because some of the WM8776 controls are used in Maya44-specific ways, and should be named appropriately.

the following files were created in pci/ice1724, simply #including the corresponding file from the alsa-kernel tree:

wtm.h

vt1720_mobo.h

revo.h

prodigy192.h

pontis.h

phase.h

maya44.h

juli.h

aureon.h

amp.h

envy24ht.h

se.h

prodigy_hifi.h

*I hope this is the correct way to do things.*

SAMPLING RATES:

The Maya44 card (or more exactly, the Wolfson WM8776 codecs) allow a maximum sampling rate of 192 kHz for playback and 92 kHz for capture.

As the ICE1724 chip only allows one global sampling rate, this is handled as follows:

* setting the sampling rate on any open PCM device on the maya44 card will always set the *global* sampling rate for all playback and capture channels.

* In the current state of the driver, setting rates of up to 192 kHz is permitted even for capture devices.

*AVOID CAPTURING AT RATES ABOVE 96kHz*, even though it may appear to work. The codec cannot actually capture at such rates, meaning poor quality.

I propose some additional code for limiting the sampling rate when setting on a capture pcm device. However because of the global sampling rate, this logic would be somewhat problematic.

The proposed code (currently deactivated) is in ice1712.h.patch, ice1724.c and maya44.c (in pci/ice1712).

SOUND DEVICES:

PCM devices correspond to inputs/outputs as follows (assuming Maya44 is card #0):

hw:0,0 input - stereo, analog input 1+2

hw:0,0 output - stereo, analog output 1+2

hw:0,1 input - stereo, analog input 3+4 OR S/PDIF input

hw:0,1 output - stereo, analog output 3+4 (and SPDIF out)

NAMING OF MIXER CONTROLS:

(for more information about the signal flow, please refer to the block diagram on p.24 of the ESI Maya44 manual, or in the ESI windows software).

PCM: (digital) output level for channel 1+2

PCM 1: same for channel 3+4

Mic Phantom+48V: switch for +48V phantom power for electrostatic microphones on input 1/2.

    Make sure this is not turned on while any other source is connected to input 1/2.

    It might damage the source and/or the maya44 card.

Mic/Line input: if switch is is on, input jack 1/2 is microphone input (mono), otherwise line input (stereo).

Bypass: analogue bypass from ADC input to output for channel 1+2. Same as "Monitor" in the windows driver.

Bypass 1: same for channel 3+4.

Crossmix: cross-mixer from channels 1+2 to channels 3+4

Crossmix 1: cross-mixer from channels 3+4 to channels 1+2

IEC958 Output: switch for S/PDIF output.

    This is not supported by the ESI windows driver.

    S/PDIF should output the same signal as channel 3+4. [untested!]

Digitial output selectors:

    These switches allow a direct digital routing from the ADCs to the DACs.

    Each switch determines where the digital input data to one of the DACs comes from.

    They are not supported by the ESI windows driver.

    For normal operation, they should all be set to "PCM out".

H/W: Output source channel 1

H/W 1: Output source channel 2

H/W 2: Output source channel 3

H/W 3: Output source channel 4

H/W 4 ... H/W 9: unknown function, left in to enable testing.

    Possibly some of these control S/PDIF output(s).

    If these turn out to be unused, they will go away in later driver versions.

Selectable values for each of the digital output selectors are:

   "PCM out" -> DAC output of the corresponding channel (default setting)

   "Input 1"...

   "Input 4" -> direct routing from ADC output of the selected input channel

--------

Feb 14, 2008

Rainer Zimmermann

mail@lightshed.de

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

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

# Toplevel Module Dependency

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

	unsigned int force_rdma1:1;	/* VT1720/4 - RDMA1 as non-spdif */

	unsigned int midi_output:1;	/* VT1720/4: MIDI output triggered */

	unsigned int midi_input:1;	/* VT1720/4: MIDI input triggered */

	unsigned int own_routing:1;	/* VT1720/4: use own routing ctls */

	unsigned int num_total_dacs;	/* total DACs */

	unsigned int num_total_adcs;	/* total ADCs */

	unsigned int cur_rate;		/* current rate */

	return  snd_ice1712_gpio_read(ice) & mask;

}

/* route access functions */

int snd_ice1724_get_route_val(struct snd_ice1712 *ice, int shift);

int snd_ice1724_put_route_val(struct snd_ice1712 *ice, unsigned int val,

								int shift);

int snd_ice1712_spdif_build_controls(struct snd_ice1712 *ice);

int snd_ice1712_akm4xxx_init(struct snd_akm4xxx *ak, const struct snd_akm4xxx *template,

			     const struct snd_ak4xxx_private *priv, struct snd_ice1712 *ice);

int snd_ice1712_akm4xxx_init(struct snd_akm4xxx *ak,

			     const struct snd_akm4xxx *template,

			     const struct snd_ak4xxx_private *priv,

			     struct snd_ice1712 *ice);

void snd_ice1712_akm4xxx_free(struct snd_ice1712 *ice);

int snd_ice1712_akm4xxx_build_controls(struct snd_ice1712 *ice);

#include "prodigy192.h"

#include "prodigy_hifi.h"

#include "juli.h"

#include "maya44.h"

#include "phase.h"

#include "wtm.h"

#include "se.h"

	       PRODIGY192_DEVICE_DESC

	       PRODIGY_HIFI_DEVICE_DESC

	       JULI_DEVICE_DESC

	       MAYA44_DEVICE_DESC

	       PHASE_DEVICE_DESC

	       WTM_DEVICE_DESC

	       SE_DEVICE_DESC

	return 0;

}

static void snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate,

static int snd_vt1724_set_pro_rate(struct snd_ice1712 *ice, unsigned int rate,

				    int force)

{

	unsigned long flags;

	unsigned int i, old_rate;

	if (rate > ice->hw_rates->list[ice->hw_rates->count - 1])

		return;

		return -EINVAL;

	spin_lock_irqsave(&ice->reg_lock, flags);

	if ((inb(ICEMT1724(ice, DMA_CONTROL)) & DMA_STARTS) ||

	    (inb(ICEMT1724(ice, DMA_PAUSE)) & DMA_PAUSES)) {

		/* running? we cannot change the rate now... */

		spin_unlock_irqrestore(&ice->reg_lock, flags);

		return;

		return -EBUSY;

	}

	if (!force && is_pro_rate_locked(ice)) {

		spin_unlock_irqrestore(&ice->reg_lock, flags);

		return;

		return (rate == ice->cur_rate) ? 0 : -EBUSY;

	}

	old_rate = ice->get_rate(ice);

		ice->set_rate(ice, rate);

	else if (rate == ice->cur_rate) {

		spin_unlock_irqrestore(&ice->reg_lock, flags);

		return;

		return 0;

	}

	ice->cur_rate = rate;

	}

	if (ice->spdif.ops.setup_rate)

		ice->spdif.ops.setup_rate(ice, rate);

	return 0;

}

static int snd_vt1724_pcm_hw_params(struct snd_pcm_substream *substream,

				    struct snd_pcm_hw_params *hw_params)

{

	struct snd_ice1712 *ice = snd_pcm_substream_chip(substream);

	int i, chs;

	int i, chs, err;

	chs = params_channels(hw_params);

	mutex_lock(&ice->open_mutex);

		}

	}

	mutex_unlock(&ice->open_mutex);

	snd_vt1724_set_pro_rate(ice, params_rate(hw_params), 0);

	err = snd_vt1724_set_pro_rate(ice, params_rate(hw_params), 0);

	if (err < 0)

		return err;

	return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));

}

#endif

}

static const struct vt1724_pcm_reg vt1724_playback_pro_reg = {

static const struct vt1724_pcm_reg vt1724_pdma0_reg = {

	.addr = VT1724_MT_PLAYBACK_ADDR,

	.size = VT1724_MT_PLAYBACK_SIZE,

	.count = VT1724_MT_PLAYBACK_COUNT,

	.start = VT1724_PDMA0_START,

};

static const struct vt1724_pcm_reg vt1724_capture_pro_reg = {

static const struct vt1724_pcm_reg vt1724_pdma4_reg = {

	.addr = VT1724_MT_PDMA4_ADDR,

	.size = VT1724_MT_PDMA4_SIZE,

	.count = VT1724_MT_PDMA4_COUNT,

	.start = VT1724_PDMA4_START,

};

static const struct vt1724_pcm_reg vt1724_rdma0_reg = {

	.addr = VT1724_MT_CAPTURE_ADDR,

	.size = VT1724_MT_CAPTURE_SIZE,

	.count = VT1724_MT_CAPTURE_COUNT,

	.start = VT1724_RDMA0_START,

};

static const struct vt1724_pcm_reg vt1724_rdma1_reg = {

	.addr = VT1724_MT_RDMA1_ADDR,

	.size = VT1724_MT_RDMA1_SIZE,

	.count = VT1724_MT_RDMA1_COUNT,

	.start = VT1724_RDMA1_START,

};

#define vt1724_playback_pro_reg vt1724_pdma0_reg

#define vt1724_playback_spdif_reg vt1724_pdma4_reg

#define vt1724_capture_pro_reg vt1724_rdma0_reg

#define vt1724_capture_spdif_reg vt1724_rdma1_reg

static const struct snd_pcm_hardware snd_vt1724_playback_pro = {

	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |

				 SNDRV_PCM_INFO_BLOCK_TRANSFER |

 * SPDIF PCM

 */

static const struct vt1724_pcm_reg vt1724_playback_spdif_reg = {

	.addr = VT1724_MT_PDMA4_ADDR,

	.size = VT1724_MT_PDMA4_SIZE,

	.count = VT1724_MT_PDMA4_COUNT,

	.start = VT1724_PDMA4_START,

};

static const struct vt1724_pcm_reg vt1724_capture_spdif_reg = {

	.addr = VT1724_MT_RDMA1_ADDR,

	.size = VT1724_MT_RDMA1_SIZE,

	.count = VT1724_MT_RDMA1_COUNT,

	.start = VT1724_RDMA1_START,

};

/* update spdif control bits; call with reg_lock */

static void update_spdif_bits(struct snd_ice1712 *ice, unsigned int val)

{

	return idx * 3;

}

static int get_route_val(struct snd_ice1712 *ice, int shift)

int snd_ice1724_get_route_val(struct snd_ice1712 *ice, int shift)

{

	unsigned long val;

	unsigned char eitem;

	return eitem;

}

static int put_route_val(struct snd_ice1712 *ice, unsigned int val, int shift)

int snd_ice1724_put_route_val(struct snd_ice1712 *ice, unsigned int val,

								int shift)

{

	unsigned int old_val, nval;

	int change;

	struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);

	int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	ucontrol->value.enumerated.item[0] =

		get_route_val(ice, analog_route_shift(idx));

		snd_ice1724_get_route_val(ice, analog_route_shift(idx));

	return 0;

}

{

	struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);

	int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	return put_route_val(ice, ucontrol->value.enumerated.item[0],

	return snd_ice1724_put_route_val(ice,

					 ucontrol->value.enumerated.item[0],

					 analog_route_shift(idx));

}

	struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);

	int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	ucontrol->value.enumerated.item[0] =

		get_route_val(ice, digital_route_shift(idx));

		snd_ice1724_get_route_val(ice, digital_route_shift(idx));

	return 0;

}

{

	struct snd_ice1712 *ice = snd_kcontrol_chip(kcontrol);

	int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);

	return put_route_val(ice, ucontrol->value.enumerated.item[0],

	return snd_ice1724_put_route_val(ice,

					 ucontrol->value.enumerated.item[0],

					 digital_route_shift(idx));

}

static struct snd_kcontrol_new snd_vt1724_mixer_pro_analog_route __devinitdata = {

static struct snd_kcontrol_new snd_vt1724_mixer_pro_analog_route __devinitdata =

{

	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,

	.name = "H/W Playback Route",

	.info = snd_vt1724_pro_route_info,

	snd_vt1724_prodigy_hifi_cards,

	snd_vt1724_prodigy192_cards,

	snd_vt1724_juli_cards,

	snd_vt1724_maya44_cards,

	snd_vt1724_phase_cards,

	snd_vt1724_wtm_cards,

	snd_vt1724_se_cards,

static void __devinit snd_vt1724_chip_reset(struct snd_ice1712 *ice)

{

	outb(VT1724_RESET , ICEREG1724(ice, CONTROL));

	inb(ICEREG1724(ice, CONTROL)); /* pci posting flush */

	msleep(10);

	outb(0, ICEREG1724(ice, CONTROL));

	inb(ICEREG1724(ice, CONTROL)); /* pci posting flush */

	msleep(10);

}

	if (snd_BUG_ON(!ice->pcm))

		return -EIO;

	err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice));

	if (!ice->own_routing) {

		err = snd_ctl_add(ice->card,

			snd_ctl_new1(&snd_vt1724_mixer_pro_spdif_route, ice));

		if (err < 0)

			return err;

	}

	err = snd_ctl_add(ice->card, snd_ctl_new1(&snd_vt1724_spdif_switch, ice));

	if (err < 0)

	if (err < 0)

		return err;

	if (ice->num_total_dacs > 0) {

	if (!ice->own_routing && ice->num_total_dacs > 0) {

		struct snd_kcontrol_new tmp = snd_vt1724_mixer_pro_analog_route;

		tmp.count = ice->num_total_dacs;

		if (ice->vt1720 && tmp.count > 2)