/* *  Copyright (c) by Jaroslav Kysela <perex@suse.cz> *  Routines for control of ESS ES1688/688/488 chip * * *   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 <sound/driver.h>#include <linux/init.h>#include <linux/interrupt.h>#include <linux/delay.h>#include <linux/slab.h>#include <linux/ioport.h>#include <sound/core.h>#include <sound/es1688.h>#include <sound/initval.h>#include <asm/io.h>#include <asm/dma.h>MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");MODULE_DESCRIPTION("ESS ESx688 lowlevel module");MODULE_LICENSE("GPL");static int snd_es1688_dsp_command(es1688_t *chip, unsigned char val){	int i;	for (i = 10000; i; i--)		if ((inb(ES1688P(chip, STATUS)) & 0x80) == 0) {			outb(val, ES1688P(chip, COMMAND));			return 1;		}#ifdef CONFIG_SND_DEBUG	printk("snd_es1688_dsp_command: timeout (0x%x)\n", val);#endif	return 0;}static int snd_es1688_dsp_get_byte(es1688_t *chip){	int i;	for (i = 1000; i; i--)		if (inb(ES1688P(chip, DATA_AVAIL)) & 0x80)			return inb(ES1688P(chip, READ));	snd_printd("es1688 get byte failed: 0x%lx = 0x%x!!!\n", ES1688P(chip, DATA_AVAIL), inb(ES1688P(chip, DATA_AVAIL)));	return -ENODEV;}static int snd_es1688_write(es1688_t *chip,			    unsigned char reg, unsigned char data){	if (!snd_es1688_dsp_command(chip, reg))		return 0;	return snd_es1688_dsp_command(chip, data);}static int snd_es1688_read(es1688_t *chip, unsigned char reg){	/* Read a byte from an extended mode register of ES1688 */	if (!snd_es1688_dsp_command(chip, 0xc0))		return -1;	if (!snd_es1688_dsp_command(chip, reg))		return -1;	return snd_es1688_dsp_get_byte(chip);}void snd_es1688_mixer_write(es1688_t *chip,			    unsigned char reg, unsigned char data){	outb(reg, ES1688P(chip, MIXER_ADDR));	udelay(10);	outb(data, ES1688P(chip, MIXER_DATA));	udelay(10);}static unsigned char snd_es1688_mixer_read(es1688_t *chip, unsigned char reg){	unsigned char result;	outb(reg, ES1688P(chip, MIXER_ADDR));	udelay(10);	result = inb(ES1688P(chip, MIXER_DATA));	udelay(10);	return result;}static int snd_es1688_reset(es1688_t *chip){	int i;	outb(3, ES1688P(chip, RESET));		/* valid only for ESS chips, SB -> 1 */	udelay(10);	outb(0, ES1688P(chip, RESET));	udelay(30);	for (i = 0; i < 1000 && !(inb(ES1688P(chip, DATA_AVAIL)) & 0x80); i++);	if (inb(ES1688P(chip, READ)) != 0xaa) {		snd_printd("ess_reset at 0x%lx: failed!!!\n", chip->port);		return -ENODEV;	}	snd_es1688_dsp_command(chip, 0xc6);	/* enable extended mode */	return 0;}static int snd_es1688_probe(es1688_t *chip){	unsigned long flags;	unsigned short major, minor, hw;	int i;	/*	 *  initialization sequence	 */	spin_lock_irqsave(&chip->reg_lock, flags);	/* Some ESS1688 cards need this */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE2));	/* ENABLE2 */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE2));	/* ENABLE2 */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE2));	/* ENABLE2 */	inb(ES1688P(chip, ENABLE1));	/* ENABLE1 */	inb(ES1688P(chip, ENABLE0));	/* ENABLE0 */	if (snd_es1688_reset(chip) < 0) {		snd_printdd("ESS: [0x%lx] reset failed... 0x%x\n", chip->port, inb(ES1688P(chip, READ)));		spin_unlock_irqrestore(&chip->reg_lock, flags);		return -ENODEV;	}	snd_es1688_dsp_command(chip, 0xe7);	/* return identification */	for (i = 1000, major = minor = 0; i; i--) {		if (inb(ES1688P(chip, DATA_AVAIL)) & 0x80) {			if (major == 0) {				major = inb(ES1688P(chip, READ));			} else {				minor = inb(ES1688P(chip, READ));			}		}	}	spin_unlock_irqrestore(&chip->reg_lock, flags);	snd_printdd("ESS: [0x%lx] found.. major = 0x%x, minor = 0x%x\n", chip->port, major, minor);	chip->version = (major << 8) | minor;	if (!chip->version)		return -ENODEV;	/* probably SB */	hw = ES1688_HW_AUTO;	switch (chip->version & 0xfff0) {	case 0x4880:		snd_printk("[0x%lx] ESS: AudioDrive ES488 detected, but driver is in another place\n", chip->port);		return -ENODEV;	case 0x6880:		hw = (chip->version & 0x0f) >= 8 ? ES1688_HW_1688 : ES1688_HW_688;		break;	default:		snd_printk("[0x%lx] ESS: unknown AudioDrive chip with version 0x%x (Jazz16 soundcard?)\n", chip->port, chip->version);		return -ENODEV;	}	spin_lock_irqsave(&chip->reg_lock, flags);	snd_es1688_write(chip, 0xb1, 0x10);	/* disable IRQ */	snd_es1688_write(chip, 0xb2, 0x00);	/* disable DMA */	spin_unlock_irqrestore(&chip->reg_lock, flags);	/* enable joystick, but disable OPL3 */	spin_lock_irqsave(&chip->mixer_lock, flags);	snd_es1688_mixer_write(chip, 0x40, 0x01);	spin_unlock_irqrestore(&chip->mixer_lock, flags);	return 0;}static int snd_es1688_init(es1688_t * chip, int enable){	static int irqs[16] = {-1, -1, 0, -1, -1, 1, -1, 2, -1, 0, 3, -1, -1, -1, -1, -1};	unsigned long flags;	int cfg, irq_bits, dma, dma_bits, tmp, tmp1;	/* ok.. setup MPU-401 port and joystick and OPL3 */	cfg = 0x01;		/* enable joystick, but disable OPL3 */	if (enable && chip->mpu_port >= 0x300 && chip->mpu_irq > 0 && chip->hardware != ES1688_HW_688) {		tmp = (chip->mpu_port & 0x0f0) >> 4;		if (tmp <= 3) {			switch (chip->mpu_irq) {			case 9:				tmp1 = 4;				break;			case 5:				tmp1 = 5;				break;			case 7:				tmp1 = 6;				break;			case 10:				tmp1 = 7;				break;			default:				tmp1 = 0;			}			if (tmp1) {				cfg |= (tmp << 3) | (tmp1 << 5);			}		}	}#if 0	snd_printk("mpu cfg = 0x%x\n", cfg);#endif	spin_lock_irqsave(&chip->reg_lock, flags);	snd_es1688_mixer_write(chip, 0x40, cfg);	spin_unlock_irqrestore(&chip->reg_lock, flags);	/* --- */	spin_lock_irqsave(&chip->reg_lock, flags);	snd_es1688_read(chip, 0xb1);	snd_es1688_read(chip, 0xb2);	spin_unlock_irqrestore(&chip->reg_lock, flags);	if (enable) {		cfg = 0xf0;	/* enable only DMA counter interrupt */		irq_bits = irqs[chip->irq & 0x0f];		if (irq_bits < 0) {			snd_printk("[0x%lx] ESS: bad IRQ %d for ES1688 chip!!\n", chip->port, chip->irq);#if 0			irq_bits = 0;			cfg = 0x10;#endif			return -EINVAL;		}		spin_lock_irqsave(&chip->reg_lock, flags);		snd_es1688_write(chip, 0xb1, cfg | (irq_bits << 2));		spin_unlock_irqrestore(&chip->reg_lock, flags);		cfg = 0xf0;	/* extended mode DMA enable */		dma = chip->dma8;		if (dma > 3 || dma == 2) {			snd_printk("[0x%lx] ESS: bad DMA channel %d for ES1688 chip!!\n", chip->port, dma);#if 0			dma_bits = 0;			cfg = 0x00;	/* disable all DMA */#endif			return -EINVAL;		} else {			dma_bits = dma;			if (dma != 3)				dma_bits++;		}		spin_lock_irqsave(&chip->reg_lock, flags);		snd_es1688_write(chip, 0xb2, cfg | (dma_bits << 2));		spin_unlock_irqrestore(&chip->reg_lock, flags);	} else {		spin_lock_irqsave(&chip->reg_lock, flags);		snd_es1688_write(chip, 0xb1, 0x10);	/* disable IRQ */		snd_es1688_write(chip, 0xb2, 0x00);	/* disable DMA */		spin_unlock_irqrestore(&chip->reg_lock, flags);	}	spin_lock_irqsave(&chip->reg_lock, flags);	snd_es1688_read(chip, 0xb1);	snd_es1688_read(chip, 0xb2);	snd_es1688_reset(chip);	spin_unlock_irqrestore(&chip->reg_lock, flags);	return 0;}/* */static ratnum_t clocks[2] = {	{		.num = 795444,		.den_min = 1,		.den_max = 128,		.den_step = 1,	},	{		.num = 397722,		.den_min = 1,		.den_max = 128,		.den_step = 1,	}};static snd_pcm_hw_constraint_ratnums_t hw_constraints_clocks  = {	.nrats = 2,	.rats = clocks,};static void snd_es1688_set_rate(es1688_t *chip, snd_pcm_substream_t *substream){	snd_pcm_runtime_t *runtime = substream->runtime;	unsigned int bits, divider;	if (runtime->rate_num == clocks[0].num)		bits = 256 - runtime->rate_den;	else		bits = 128 - runtime->rate_den;	/* set filter register */	divider = 256 - 7160000*20/(8*82*runtime->rate);	/* write result to hardware */	snd_es1688_write(chip, 0xa1, bits);	snd_es1688_write(chip, 0xa2, divider);}static int snd_es1688_ioctl(snd_pcm_substream_t * substream,			    unsigned int cmd, void *arg){	return snd_pcm_lib_ioctl(substream, cmd, arg);}static int snd_es1688_trigger(es1688_t *chip, int cmd, unsigned char value){	int val;	if (cmd == SNDRV_PCM_TRIGGER_STOP) {		value = 0x00;	} else if (cmd != SNDRV_PCM_TRIGGER_START) {		return -EINVAL;	}	spin_lock(&chip->reg_lock);	chip->trigger_value = value;	val = snd_es1688_read(chip, 0xb8);	if ((val < 0) || (val & 0x0f) == value) {		spin_unlock(&chip->reg_lock);		return -EINVAL;	/* something is wrong */	}#if 0	printk("trigger: val = 0x%x, value = 0x%x\n", val, value);	printk("trigger: pointer = 0x%x\n", snd_dma_pointer(chip->dma8, chip->dma_size));#endif	snd_es1688_write(chip, 0xb8, (val & 0xf0) | value);	spin_unlock(&chip->reg_lock);	return 0;}static int snd_es1688_hw_params(snd_pcm_substream_t * substream,				snd_pcm_hw_params_t * hw_params)