[linux.git] / sound / drivers / vx / vx_uer.c

/*
 * Driver for Digigram VX soundcards
 *
 * IEC958 stuff
 *
 * Copyright (c) 2002 by Takashi Iwai <[email protected]>
 *
 *   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 <sound/core.h>
#include <sound/vx_core.h>
#include "vx_cmd.h"


/*
 * vx_modify_board_clock - tell the board that its clock has been modified
 * @sync: DSP needs to resynchronize its FIFO
 */
static int vx_modify_board_clock(struct vx_core *chip, int sync)
{
	struct vx_rmh rmh;

	vx_init_rmh(&rmh, CMD_MODIFY_CLOCK);
	/* Ask the DSP to resynchronize its FIFO. */
	if (sync)
		rmh.Cmd[0] |= CMD_MODIFY_CLOCK_S_BIT;
	return vx_send_msg(chip, &rmh);
}

/*
 * vx_modify_board_inputs - resync audio inputs
 */
static int vx_modify_board_inputs(struct vx_core *chip)
{
	struct vx_rmh rmh;

	vx_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS);
        rmh.Cmd[0] |= 1 << 0; /* reference: AUDIO 0 */
	return vx_send_msg(chip, &rmh);
}

/*
 * vx_read_one_cbit - read one bit from UER config
 * @index: the bit index
 * returns 0 or 1.
 */
static int vx_read_one_cbit(struct vx_core *chip, int index)
{
	int val;

	mutex_lock(&chip->lock);
	if (chip->type >= VX_TYPE_VXPOCKET) {
		vx_outb(chip, CSUER, 1); /* read */
		vx_outb(chip, RUER, index & XX_UER_CBITS_OFFSET_MASK);
		val = (vx_inb(chip, RUER) >> 7) & 0x01;
	} else {
		vx_outl(chip, CSUER, 1); /* read */
		vx_outl(chip, RUER, index & XX_UER_CBITS_OFFSET_MASK);
		val = (vx_inl(chip, RUER) >> 7) & 0x01;
	}
	mutex_unlock(&chip->lock);
	return val;
}

/*
 * vx_write_one_cbit - write one bit to UER config
 * @index: the bit index
 * @val: bit value, 0 or 1
 */
static void vx_write_one_cbit(struct vx_core *chip, int index, int val)
{
	val = !!val;	/* 0 or 1 */
	mutex_lock(&chip->lock);
	if (vx_is_pcmcia(chip)) {
		vx_outb(chip, CSUER, 0); /* write */
		vx_outb(chip, RUER, (val << 7) | (index & XX_UER_CBITS_OFFSET_MASK));
	} else {
		vx_outl(chip, CSUER, 0); /* write */
		vx_outl(chip, RUER, (val << 7) | (index & XX_UER_CBITS_OFFSET_MASK));
	}
	mutex_unlock(&chip->lock);
}

/*
 * vx_read_uer_status - read the current UER status
 * @mode: pointer to store the UER mode, VX_UER_MODE_XXX
 *
 * returns the frequency of UER, or 0 if not sync,
 * or a negative error code.
 */
static int vx_read_uer_status(struct vx_core *chip, unsigned int *mode)
{
	int val, freq;

	/* Default values */
	freq = 0;

	/* Read UER status */
	if (vx_is_pcmcia(chip))
	    val = vx_inb(chip, CSUER);
	else
	    val = vx_inl(chip, CSUER);
	if (val < 0)
		return val;
	/* If clock is present, read frequency */
	if (val & VX_SUER_CLOCK_PRESENT_MASK) {
		switch (val & VX_SUER_FREQ_MASK) {
		case VX_SUER_FREQ_32KHz_MASK:
			freq = 32000;
			break;
		case VX_SUER_FREQ_44KHz_MASK:
			freq = 44100;
			break;
		case VX_SUER_FREQ_48KHz_MASK:
			freq = 48000;
			break;
		}
        }
	if (val & VX_SUER_DATA_PRESENT_MASK)
		/* bit 0 corresponds to consumer/professional bit */
		*mode = vx_read_one_cbit(chip, 0) ?
			VX_UER_MODE_PROFESSIONAL : VX_UER_MODE_CONSUMER;
	else
		*mode = VX_UER_MODE_NOT_PRESENT;

	return freq;
}


/*
 * compute the sample clock value from frequency
 *
 * The formula is as follows:
 *
 *    HexFreq = (dword) ((double) ((double) 28224000 / (double) Frequency))
 *    switch ( HexFreq & 0x00000F00 )
 *    case 0x00000100: ;
 *    case 0x00000200:
 *    case 0x00000300: HexFreq -= 0x00000201 ;
 *    case 0x00000400:
 *    case 0x00000500:
 *    case 0x00000600:
 *    case 0x00000700: HexFreq = (dword) (((double) 28224000 / (double) (Frequency*2)) - 1)
 *    default        : HexFreq = (dword) ((double) 28224000 / (double) (Frequency*4)) - 0x000001FF
 */

static int vx_calc_clock_from_freq(struct vx_core *chip, int freq)
{
	int hexfreq;

	if (snd_BUG_ON(freq <= 0))
		return 0;

	hexfreq = (28224000 * 10) / freq;
	hexfreq = (hexfreq + 5) / 10;

	/* max freq = 55125 Hz */
	if (snd_BUG_ON(hexfreq <= 0x00000200))
		return 0;

	if (hexfreq <= 0x03ff)
		return hexfreq - 0x00000201;
	if (hexfreq <= 0x07ff) 
		return (hexfreq / 2) - 1;
	if (hexfreq <= 0x0fff)
		return (hexfreq / 4) + 0x000001ff;

	return 0x5fe; 	/* min freq = 6893 Hz */
}


/*
 * vx_change_clock_source - change the clock source
 * @source: the new source
 */
static void vx_change_clock_source(struct vx_core *chip, int source)
{
	/* we mute DAC to prevent clicks */
	vx_toggle_dac_mute(chip, 1);
	mutex_lock(&chip->lock);
	chip->ops->set_clock_source(chip, source);
	chip->clock_source = source;
	mutex_unlock(&chip->lock);
	/* unmute */
	vx_toggle_dac_mute(chip, 0);
}


/*
 * set the internal clock
 */
void vx_set_internal_clock(struct vx_core *chip, unsigned int freq)
{
	int clock;

	/* Get real clock value */
	clock = vx_calc_clock_from_freq(chip, freq);
	snd_printdd(KERN_DEBUG "set internal clock to 0x%x from freq %d\n", clock, freq);
	mutex_lock(&chip->lock);
	if (vx_is_pcmcia(chip)) {
		vx_outb(chip, HIFREQ, (clock >> 8) & 0x0f);
		vx_outb(chip, LOFREQ, clock & 0xff);
	} else {
		vx_outl(chip, HIFREQ, (clock >> 8) & 0x0f);
		vx_outl(chip, LOFREQ, clock & 0xff);
	}
	mutex_unlock(&chip->lock);
}


/*
 * set the iec958 status bits
 * @bits: 32-bit status bits
 */
void vx_set_iec958_status(struct vx_core *chip, unsigned int bits)
{
	int i;

	if (chip->chip_status & VX_STAT_IS_STALE)
		return;

	for (i = 0; i < 32; i++)
		vx_write_one_cbit(chip, i, bits & (1 << i));
}


/*
 * vx_set_clock - change the clock and audio source if necessary
 */
int vx_set_clock(struct vx_core *chip, unsigned int freq)
{
	int src_changed = 0;

	if (chip->chip_status & VX_STAT_IS_STALE)
		return 0;

	/* change the audio source if possible */
	vx_sync_audio_source(chip);

	if (chip->clock_mode == VX_CLOCK_MODE_EXTERNAL ||
	    (chip->clock_mode == VX_CLOCK_MODE_AUTO &&
	     chip->audio_source == VX_AUDIO_SRC_DIGITAL)) {
		if (chip->clock_source != UER_SYNC) {
			vx_change_clock_source(chip, UER_SYNC);
			mdelay(6);
			src_changed = 1;
		}
	} else if (chip->clock_mode == VX_CLOCK_MODE_INTERNAL ||
		   (chip->clock_mode == VX_CLOCK_MODE_AUTO &&
		    chip->audio_source != VX_AUDIO_SRC_DIGITAL)) {
		if (chip->clock_source != INTERNAL_QUARTZ) {
			vx_change_clock_source(chip, INTERNAL_QUARTZ);
			src_changed = 1;
		}
		if (chip->freq == freq)
			return 0;
		vx_set_internal_clock(chip, freq);
		if (src_changed)
			vx_modify_board_inputs(chip);
	}
	if (chip->freq == freq)
		return 0;
	chip->freq = freq;
	vx_modify_board_clock(chip, 1);
	return 0;
}


/*
 * vx_change_frequency - called from interrupt handler
 */
int vx_change_frequency(struct vx_core *chip)
{
	int freq;

	if (chip->chip_status & VX_STAT_IS_STALE)
		return 0;

	if (chip->clock_source == INTERNAL_QUARTZ)
		return 0;
	/*
	 * Read the real UER board frequency
	 */
	freq = vx_read_uer_status(chip, &chip->uer_detected);
	if (freq < 0)
		return freq;
	/*
	 * The frequency computed by the DSP is good and
	 * is different from the previous computed.
	 */
	if (freq == 48000 || freq == 44100 || freq == 32000)
		chip->freq_detected = freq;

	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Driver for Digigram VX soundcards
	3	*
	4	* IEC958 stuff
	5	*
	6	* Copyright (c) 2002 by Takashi Iwai <[email protected]>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	21	*/
	22
1da177e4 LT	23	#include <linux/delay.h>
	24	#include <sound/core.h>
	25	#include <sound/vx_core.h>
	26	#include "vx_cmd.h"
	27
	28
	29	/*
	30	* vx_modify_board_clock - tell the board that its clock has been modified
	31	* @sync: DSP needs to resynchronize its FIFO
	32	*/
af26367f	33	static int vx_modify_board_clock(struct vx_core *chip, int sync)
1da177e4 LT	34	{
	35	struct vx_rmh rmh;
	36
	37	vx_init_rmh(&rmh, CMD_MODIFY_CLOCK);
	38	/* Ask the DSP to resynchronize its FIFO. */
	39	if (sync)
	40	rmh.Cmd[0] \|= CMD_MODIFY_CLOCK_S_BIT;
	41	return vx_send_msg(chip, &rmh);
	42	}
	43
	44	/*
	45	* vx_modify_board_inputs - resync audio inputs
	46	*/
af26367f	47	static int vx_modify_board_inputs(struct vx_core *chip)
1da177e4 LT	48	{
	49	struct vx_rmh rmh;
	50
	51	vx_init_rmh(&rmh, CMD_RESYNC_AUDIO_INPUTS);
	52	rmh.Cmd[0] \|= 1 << 0; /* reference: AUDIO 0 */
	53	return vx_send_msg(chip, &rmh);
	54	}
	55
	56	/*
	57	* vx_read_one_cbit - read one bit from UER config
	58	* @index: the bit index
	59	* returns 0 or 1.
	60	*/
af26367f	61	static int vx_read_one_cbit(struct vx_core *chip, int index)
1da177e4	62	{
1da177e4	63	int val;
db0a5214 TI	64
db0a5214 TI	65	mutex_lock(&chip->lock);
1da177e4 LT	66	if (chip->type >= VX_TYPE_VXPOCKET) {
	67	vx_outb(chip, CSUER, 1); /* read */
	68	vx_outb(chip, RUER, index & XX_UER_CBITS_OFFSET_MASK);
	69	val = (vx_inb(chip, RUER) >> 7) & 0x01;
	70	} else {
	71	vx_outl(chip, CSUER, 1); /* read */
	72	vx_outl(chip, RUER, index & XX_UER_CBITS_OFFSET_MASK);
	73	val = (vx_inl(chip, RUER) >> 7) & 0x01;
	74	}
db0a5214	75	mutex_unlock(&chip->lock);
1da177e4 LT	76	return val;
	77	}
	78
	79	/*
	80	* vx_write_one_cbit - write one bit to UER config
	81	* @index: the bit index
	82	* @val: bit value, 0 or 1
	83	*/
af26367f	84	static void vx_write_one_cbit(struct vx_core *chip, int index, int val)
1da177e4	85	{
1da177e4	86	val = !!val; /* 0 or 1 */
db0a5214	87	mutex_lock(&chip->lock);
1da177e4 LT	88	if (vx_is_pcmcia(chip)) {
	89	vx_outb(chip, CSUER, 0); /* write */
	90	vx_outb(chip, RUER, (val << 7) \| (index & XX_UER_CBITS_OFFSET_MASK));
	91	} else {
	92	vx_outl(chip, CSUER, 0); /* write */
	93	vx_outl(chip, RUER, (val << 7) \| (index & XX_UER_CBITS_OFFSET_MASK));
	94	}
db0a5214	95	mutex_unlock(&chip->lock);
1da177e4 LT	96	}
	97
	98	/*
	99	* vx_read_uer_status - read the current UER status
	100	* @mode: pointer to store the UER mode, VX_UER_MODE_XXX
	101	*
	102	* returns the frequency of UER, or 0 if not sync,
	103	* or a negative error code.
	104	*/
d73d341d	105	static int vx_read_uer_status(struct vx_core chip, unsigned int mode)
1da177e4 LT	106	{
	107	int val, freq;
	108
	109	/* Default values */
	110	freq = 0;
	111
	112	/* Read UER status */
	113	if (vx_is_pcmcia(chip))
	114	val = vx_inb(chip, CSUER);
	115	else
	116	val = vx_inl(chip, CSUER);
	117	if (val < 0)
	118	return val;
	119	/* If clock is present, read frequency */
	120	if (val & VX_SUER_CLOCK_PRESENT_MASK) {
	121	switch (val & VX_SUER_FREQ_MASK) {
	122	case VX_SUER_FREQ_32KHz_MASK:
	123	freq = 32000;
	124	break;
	125	case VX_SUER_FREQ_44KHz_MASK:
	126	freq = 44100;
	127	break;
	128	case VX_SUER_FREQ_48KHz_MASK:
	129	freq = 48000;
	130	break;
	131	}
	132	}
	133	if (val & VX_SUER_DATA_PRESENT_MASK)
	134	/* bit 0 corresponds to consumer/professional bit */
	135	*mode = vx_read_one_cbit(chip, 0) ?
	136	VX_UER_MODE_PROFESSIONAL : VX_UER_MODE_CONSUMER;
	137	else
	138	*mode = VX_UER_MODE_NOT_PRESENT;
	139
	140	return freq;
	141	}
	142
	143
	144	/*
	145	* compute the sample clock value from frequency
	146	*
	147	* The formula is as follows:
	148	*
	149	* HexFreq = (dword) ((double) ((double) 28224000 / (double) Frequency))
	150	* switch ( HexFreq & 0x00000F00 )
	151	* case 0x00000100: ;
	152	* case 0x00000200:
	153	* case 0x00000300: HexFreq -= 0x00000201 ;
	154	* case 0x00000400:
	155	* case 0x00000500:
	156	* case 0x00000600:
	157	* case 0x00000700: HexFreq = (dword) (((double) 28224000 / (double) (Frequency*2)) - 1)
	158	* default : HexFreq = (dword) ((double) 28224000 / (double) (Frequency*4)) - 0x000001FF
	159	*/
	160
af26367f	161	static int vx_calc_clock_from_freq(struct vx_core *chip, int freq)
1da177e4	162	{
7b566054 TI	163	int hexfreq;
7b566054 TI	164
5e246b85 TI	165	if (snd_BUG_ON(freq <= 0))
5e246b85 TI	166	return 0;
7b566054 TI	167
	168	hexfreq = (28224000 * 10) / freq;
	169	hexfreq = (hexfreq + 5) / 10;
	170
	171	/* max freq = 55125 Hz */
5e246b85 TI	172	if (snd_BUG_ON(hexfreq <= 0x00000200))
5e246b85 TI	173	return 0;
7b566054 TI	174
	175	if (hexfreq <= 0x03ff)
	176	return hexfreq - 0x00000201;
	177	if (hexfreq <= 0x07ff)
	178	return (hexfreq / 2) - 1;
	179	if (hexfreq <= 0x0fff)
	180	return (hexfreq / 4) + 0x000001ff;
	181
	182	return 0x5fe; /* min freq = 6893 Hz */
1da177e4 LT	183	}
	184
	185
	186	/*
	187	* vx_change_clock_source - change the clock source
	188	* @source: the new source
	189	*/
af26367f	190	static void vx_change_clock_source(struct vx_core *chip, int source)
1da177e4	191	{
1da177e4 LT	192	/* we mute DAC to prevent clicks */
1da177e4 LT	193	vx_toggle_dac_mute(chip, 1);
db0a5214	194	mutex_lock(&chip->lock);
1da177e4 LT	195	chip->ops->set_clock_source(chip, source);
1da177e4 LT	196	chip->clock_source = source;
db0a5214	197	mutex_unlock(&chip->lock);
1da177e4 LT	198	/* unmute */
	199	vx_toggle_dac_mute(chip, 0);
	200	}
	201
	202
	203	/*
	204	* set the internal clock
	205	*/
af26367f	206	void vx_set_internal_clock(struct vx_core *chip, unsigned int freq)
1da177e4 LT	207	{
1da177e4 LT	208	int clock;
db0a5214	209
1da177e4 LT	210	/* Get real clock value */
	211	clock = vx_calc_clock_from_freq(chip, freq);
	212	snd_printdd(KERN_DEBUG "set internal clock to 0x%x from freq %d\n", clock, freq);
db0a5214	213	mutex_lock(&chip->lock);
1da177e4 LT	214	if (vx_is_pcmcia(chip)) {
	215	vx_outb(chip, HIFREQ, (clock >> 8) & 0x0f);
	216	vx_outb(chip, LOFREQ, clock & 0xff);
	217	} else {
	218	vx_outl(chip, HIFREQ, (clock >> 8) & 0x0f);
	219	vx_outl(chip, LOFREQ, clock & 0xff);
	220	}
db0a5214	221	mutex_unlock(&chip->lock);
1da177e4 LT	222	}
	223
	224
	225	/*
	226	* set the iec958 status bits
	227	* @bits: 32-bit status bits
	228	*/
af26367f	229	void vx_set_iec958_status(struct vx_core *chip, unsigned int bits)
1da177e4 LT	230	{
	231	int i;
	232
	233	if (chip->chip_status & VX_STAT_IS_STALE)
	234	return;
	235
	236	for (i = 0; i < 32; i++)
	237	vx_write_one_cbit(chip, i, bits & (1 << i));
	238	}
	239
	240
	241	/*
	242	* vx_set_clock - change the clock and audio source if necessary
	243	*/
af26367f	244	int vx_set_clock(struct vx_core *chip, unsigned int freq)
1da177e4 LT	245	{
	246	int src_changed = 0;
	247
	248	if (chip->chip_status & VX_STAT_IS_STALE)
	249	return 0;
	250
	251	/* change the audio source if possible */
	252	vx_sync_audio_source(chip);
	253
	254	if (chip->clock_mode == VX_CLOCK_MODE_EXTERNAL \|\|
	255	(chip->clock_mode == VX_CLOCK_MODE_AUTO &&
	256	chip->audio_source == VX_AUDIO_SRC_DIGITAL)) {
	257	if (chip->clock_source != UER_SYNC) {
	258	vx_change_clock_source(chip, UER_SYNC);
	259	mdelay(6);
	260	src_changed = 1;
	261	}
	262	} else if (chip->clock_mode == VX_CLOCK_MODE_INTERNAL \|\|
	263	(chip->clock_mode == VX_CLOCK_MODE_AUTO &&
	264	chip->audio_source != VX_AUDIO_SRC_DIGITAL)) {
	265	if (chip->clock_source != INTERNAL_QUARTZ) {
	266	vx_change_clock_source(chip, INTERNAL_QUARTZ);
	267	src_changed = 1;
	268	}
	269	if (chip->freq == freq)
	270	return 0;
	271	vx_set_internal_clock(chip, freq);
	272	if (src_changed)
	273	vx_modify_board_inputs(chip);
	274	}
	275	if (chip->freq == freq)
	276	return 0;
	277	chip->freq = freq;
	278	vx_modify_board_clock(chip, 1);
	279	return 0;
	280	}
	281
	282
	283	/*
	284	* vx_change_frequency - called from interrupt handler
	285	*/
af26367f	286	int vx_change_frequency(struct vx_core *chip)
1da177e4 LT	287	{
	288	int freq;
	289
	290	if (chip->chip_status & VX_STAT_IS_STALE)
	291	return 0;
	292
	293	if (chip->clock_source == INTERNAL_QUARTZ)
	294	return 0;
	295	/*
	296	* Read the real UER board frequency
	297	*/
	298	freq = vx_read_uer_status(chip, &chip->uer_detected);
	299	if (freq < 0)
	300	return freq;
	301	/*
	302	* The frequency computed by the DSP is good and
	303	* is different from the previous computed.
	304	*/
	305	if (freq == 48000 \|\| freq == 44100 \|\| freq == 32000)
	306	chip->freq_detected = freq;
	307
	308	return 0;
	309	}