[deliverable/linux.git] / sound / pci / cs5535audio / cs5535audio_pcm.c

/*
 * Driver for audio on multifunction CS5535 companion device
 * Copyright (C) Jaya Kumar
 *
 * Based on Jaroslav Kysela and Takashi Iwai's examples.
 * This work was sponsored by CIS(M) Sdn Bhd.
 *
 * 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
 *
 * todo: add be fmt support, spdif, pm
 */

#include <linux/init.h>
#include <linux/slab.h>
#include <linux/pci.h>
#include <sound/driver.h>
#include <sound/core.h>
#include <sound/control.h>
#include <sound/initval.h>
#include <sound/asoundef.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/ac97_codec.h>
#include "cs5535audio.h"

static struct snd_pcm_hardware snd_cs5535audio_playback =
{
	.info =			(
				SNDRV_PCM_INFO_MMAP |
				SNDRV_PCM_INFO_INTERLEAVED |
		 		SNDRV_PCM_INFO_BLOCK_TRANSFER |
		 		SNDRV_PCM_INFO_MMAP_VALID |
		 		SNDRV_PCM_INFO_PAUSE |
				SNDRV_PCM_INFO_SYNC_START |
				SNDRV_PCM_INFO_RESUME
				),
	.formats =		(
				SNDRV_PCM_FMTBIT_S16_LE
				),
	.rates =		(
				SNDRV_PCM_RATE_CONTINUOUS |
				SNDRV_PCM_RATE_8000_48000
				),
	.rate_min =		4000,
	.rate_max =		48000,
	.channels_min =		2,
	.channels_max =		2,
	.buffer_bytes_max =	(128*1024),
	.period_bytes_min =	64,
	.period_bytes_max =	(64*1024 - 16),
	.periods_min =		1,
	.periods_max =		CS5535AUDIO_MAX_DESCRIPTORS,
	.fifo_size =		0,
};

static struct snd_pcm_hardware snd_cs5535audio_capture =
{
	.info =			(
				SNDRV_PCM_INFO_MMAP |
				SNDRV_PCM_INFO_INTERLEAVED |
		 		SNDRV_PCM_INFO_BLOCK_TRANSFER |
		 		SNDRV_PCM_INFO_MMAP_VALID |
				SNDRV_PCM_INFO_SYNC_START
				),
	.formats =		(
				SNDRV_PCM_FMTBIT_S16_LE
				),
	.rates =		(
				SNDRV_PCM_RATE_CONTINUOUS |
				SNDRV_PCM_RATE_8000_48000
				),
	.rate_min =		4000,
	.rate_max =		48000,
	.channels_min =		2,
	.channels_max =		2,
	.buffer_bytes_max =	(128*1024),
	.period_bytes_min =	64,
	.period_bytes_max =	(64*1024 - 16),
	.periods_min =		1,
	.periods_max =		CS5535AUDIO_MAX_DESCRIPTORS,
	.fifo_size =		0,
};

static int snd_cs5535audio_playback_open(struct snd_pcm_substream *substream)
{
	int err;
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;

	runtime->hw = snd_cs5535audio_playback;
	cs5535au->playback_substream = substream;
	runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK]);
	snd_pcm_set_sync(substream);
	if ((err = snd_pcm_hw_constraint_integer(runtime,
				SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
		return err;

	return 0;
}

static int snd_cs5535audio_playback_close(struct snd_pcm_substream *substream)
{
	return 0;
}

#define CS5535AUDIO_DESC_LIST_SIZE \
	PAGE_ALIGN(CS5535AUDIO_MAX_DESCRIPTORS * sizeof(struct cs5535audio_dma_desc))

static int cs5535audio_build_dma_packets(struct cs5535audio *cs5535au,
					 struct cs5535audio_dma *dma,
					 struct snd_pcm_substream *substream,
					 unsigned int periods,
					 unsigned int period_bytes)
{
	unsigned int i;
	u32 addr, desc_addr, jmpprd_addr;
	struct cs5535audio_dma_desc *lastdesc;

	if (periods > CS5535AUDIO_MAX_DESCRIPTORS)
		return -ENOMEM;

	if (dma->desc_buf.area == NULL) {
		if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
					snd_dma_pci_data(cs5535au->pci),
					CS5535AUDIO_DESC_LIST_SIZE+1,
					&dma->desc_buf) < 0)
			return -ENOMEM;
		dma->period_bytes = dma->periods = 0;
	}

	if (dma->periods == periods && dma->period_bytes == period_bytes)
		return 0;

	/* the u32 cast is okay because in snd*create we successfully told
   	   pci alloc that we're only 32 bit capable so the uppper will be 0 */
	addr = (u32) substream->runtime->dma_addr;
	desc_addr = (u32) dma->desc_buf.addr;
	for (i = 0; i < periods; i++) {
		struct cs5535audio_dma_desc *desc =
			&((struct cs5535audio_dma_desc *) dma->desc_buf.area)[i];
		desc->addr = cpu_to_le32(addr);
		desc->size = cpu_to_le32(period_bytes);
		desc->ctlreserved = cpu_to_le32(PRD_EOP);
		desc_addr += sizeof(struct cs5535audio_dma_desc);
		addr += period_bytes;
	}
	/* we reserved one dummy descriptor at the end to do the PRD jump */
	lastdesc = &((struct cs5535audio_dma_desc *) dma->desc_buf.area)[periods];
	lastdesc->addr = cpu_to_le32((u32) dma->desc_buf.addr);
	lastdesc->size = 0;
	lastdesc->ctlreserved = cpu_to_le32(PRD_JMP);
	jmpprd_addr = cpu_to_le32(lastdesc->addr +
				  (sizeof(struct cs5535audio_dma_desc)*periods));

	dma->period_bytes = period_bytes;
	dma->periods = periods;
	spin_lock_irq(&cs5535au->reg_lock);
	dma->ops->disable_dma(cs5535au);
	dma->ops->setup_prd(cs5535au, jmpprd_addr);
	spin_unlock_irq(&cs5535au->reg_lock);
	return 0;
}

static void cs5535audio_playback_enable_dma(struct cs5535audio *cs5535au)
{
	cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_EN);
}

static void cs5535audio_playback_disable_dma(struct cs5535audio *cs5535au)
{
	cs_writeb(cs5535au, ACC_BM0_CMD, 0);
}

static void cs5535audio_playback_pause_dma(struct cs5535audio *cs5535au)
{
	cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_PAUSE);
}

static void cs5535audio_playback_setup_prd(struct cs5535audio *cs5535au,
					   u32 prd_addr)
{
	cs_writel(cs5535au, ACC_BM0_PRD, prd_addr);
}

static u32 cs5535audio_playback_read_prd(struct cs5535audio *cs5535au)
{
	return cs_readl(cs5535au, ACC_BM0_PRD);
}

static u32 cs5535audio_playback_read_dma_pntr(struct cs5535audio *cs5535au)
{
	return cs_readl(cs5535au, ACC_BM0_PNTR);
}

static void cs5535audio_capture_enable_dma(struct cs5535audio *cs5535au)
{
	cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_EN);
}

static void cs5535audio_capture_disable_dma(struct cs5535audio *cs5535au)
{
	cs_writeb(cs5535au, ACC_BM1_CMD, 0);
}

static void cs5535audio_capture_pause_dma(struct cs5535audio *cs5535au)
{
	cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_PAUSE);
}

static void cs5535audio_capture_setup_prd(struct cs5535audio *cs5535au,
					  u32 prd_addr)
{
	cs_writel(cs5535au, ACC_BM1_PRD, prd_addr);
}

static u32 cs5535audio_capture_read_prd(struct cs5535audio *cs5535au)
{
	return cs_readl(cs5535au, ACC_BM1_PRD);
}

static u32 cs5535audio_capture_read_dma_pntr(struct cs5535audio *cs5535au)
{
	return cs_readl(cs5535au, ACC_BM1_PNTR);
}

static void cs5535audio_clear_dma_packets(struct cs5535audio *cs5535au,
					  struct cs5535audio_dma *dma,
					  struct snd_pcm_substream *substream)
{
	snd_dma_free_pages(&dma->desc_buf);
	dma->desc_buf.area = NULL;
}

static int snd_cs5535audio_hw_params(struct snd_pcm_substream *substream,
				     struct snd_pcm_hw_params *hw_params)
{
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	struct cs5535audio_dma *dma = substream->runtime->private_data;
	int err;

	err = snd_pcm_lib_malloc_pages(substream,
					params_buffer_bytes(hw_params));
	if (err < 0)
		return err;
	dma->buf_addr = substream->runtime->dma_addr;
	dma->buf_bytes = params_buffer_bytes(hw_params);

	err = cs5535audio_build_dma_packets(cs5535au, dma, substream,
					    params_periods(hw_params),
					    params_period_bytes(hw_params));
	return err;
}

static int snd_cs5535audio_hw_free(struct snd_pcm_substream *substream)
{
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	struct cs5535audio_dma *dma = substream->runtime->private_data;

	cs5535audio_clear_dma_packets(cs5535au, dma, substream);
	return snd_pcm_lib_free_pages(substream);
}

static int snd_cs5535audio_playback_prepare(struct snd_pcm_substream *substream)
{
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_FRONT_DAC_RATE,
				 substream->runtime->rate);
}

static int snd_cs5535audio_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	struct cs5535audio_dma *dma = substream->runtime->private_data;
	int err = 0;

	spin_lock(&cs5535au->reg_lock);
	switch (cmd) {
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		dma->ops->pause_dma(cs5535au);
		break;
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		dma->ops->enable_dma(cs5535au);
		break;
	case SNDRV_PCM_TRIGGER_START:
		dma->ops->enable_dma(cs5535au);
		break;
	case SNDRV_PCM_TRIGGER_RESUME:
		dma->ops->enable_dma(cs5535au);
		dma->suspended = 0;
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		dma->ops->disable_dma(cs5535au);
		break;
	case SNDRV_PCM_TRIGGER_SUSPEND:
		dma->ops->disable_dma(cs5535au);
		dma->suspended = 1;
		break;
	default:
		snd_printk(KERN_ERR "unhandled trigger\n");
		err = -EINVAL;
		break;
	}
	spin_unlock(&cs5535au->reg_lock);
	return err;
}

static snd_pcm_uframes_t snd_cs5535audio_pcm_pointer(struct snd_pcm_substream
							*substream)
{
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	u32 curdma;
	struct cs5535audio_dma *dma;

	dma = substream->runtime->private_data;
	curdma = dma->ops->read_dma_pntr(cs5535au);
	if (curdma < dma->buf_addr) {
		snd_printk(KERN_ERR "curdma=%x < %x bufaddr.\n",
					curdma, dma->buf_addr);
		return 0;
	}
	curdma -= dma->buf_addr;
	if (curdma >= dma->buf_bytes) {
		snd_printk(KERN_ERR "diff=%x >= %x buf_bytes.\n",
					curdma, dma->buf_bytes);
		return 0;
	}
	return bytes_to_frames(substream->runtime, curdma);
}

static int snd_cs5535audio_capture_open(struct snd_pcm_substream *substream)
{
	int err;
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;

	runtime->hw = snd_cs5535audio_capture;
	cs5535au->capture_substream = substream;
	runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE]);
	snd_pcm_set_sync(substream);
	if ((err = snd_pcm_hw_constraint_integer(runtime,
					 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
		return err;
	return 0;
}

static int snd_cs5535audio_capture_close(struct snd_pcm_substream *substream)
{
	return 0;
}

static int snd_cs5535audio_capture_prepare(struct snd_pcm_substream *substream)
{
	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
	return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_LR_ADC_RATE,
				 substream->runtime->rate);
}

static struct snd_pcm_ops snd_cs5535audio_playback_ops = {
	.open =		snd_cs5535audio_playback_open,
	.close =	snd_cs5535audio_playback_close,
	.ioctl =	snd_pcm_lib_ioctl,
	.hw_params =	snd_cs5535audio_hw_params,
	.hw_free =	snd_cs5535audio_hw_free,
	.prepare =	snd_cs5535audio_playback_prepare,
	.trigger =	snd_cs5535audio_trigger,
	.pointer =	snd_cs5535audio_pcm_pointer,
};

static struct snd_pcm_ops snd_cs5535audio_capture_ops = {
	.open =		snd_cs5535audio_capture_open,
	.close =	snd_cs5535audio_capture_close,
	.ioctl =	snd_pcm_lib_ioctl,
	.hw_params =	snd_cs5535audio_hw_params,
	.hw_free =	snd_cs5535audio_hw_free,
	.prepare =	snd_cs5535audio_capture_prepare,
	.trigger =	snd_cs5535audio_trigger,
	.pointer =	snd_cs5535audio_pcm_pointer,
};

static struct cs5535audio_dma_ops snd_cs5535audio_playback_dma_ops = {
        .type = CS5535AUDIO_DMA_PLAYBACK,
        .enable_dma = cs5535audio_playback_enable_dma,
        .disable_dma = cs5535audio_playback_disable_dma,
        .setup_prd = cs5535audio_playback_setup_prd,
        .read_prd = cs5535audio_playback_read_prd,
        .pause_dma = cs5535audio_playback_pause_dma,
        .read_dma_pntr = cs5535audio_playback_read_dma_pntr,
};

static struct cs5535audio_dma_ops snd_cs5535audio_capture_dma_ops = {
        .type = CS5535AUDIO_DMA_CAPTURE,
        .enable_dma = cs5535audio_capture_enable_dma,
        .disable_dma = cs5535audio_capture_disable_dma,
        .setup_prd = cs5535audio_capture_setup_prd,
        .read_prd = cs5535audio_capture_read_prd,
        .pause_dma = cs5535audio_capture_pause_dma,
        .read_dma_pntr = cs5535audio_capture_read_dma_pntr,
};

int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535au)
{
	struct snd_pcm *pcm;
	int err;

	err = snd_pcm_new(cs5535au->card, "CS5535 Audio", 0, 1, 1, &pcm);
	if (err < 0)
		return err;

	cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK].ops =
					&snd_cs5535audio_playback_dma_ops;
	cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE].ops =
					&snd_cs5535audio_capture_dma_ops;
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
					&snd_cs5535audio_playback_ops);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
					&snd_cs5535audio_capture_ops);

	pcm->private_data = cs5535au;
	pcm->info_flags = 0;
	strcpy(pcm->name, "CS5535 Audio");

	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
					snd_dma_pci_data(cs5535au->pci),
					64*1024, 128*1024);
	cs5535au->pcm = pcm;

	return 0;
}
Commit	Line	Data
9b4ffa48 JK	1	/*
	2	* Driver for audio on multifunction CS5535 companion device
	3	* Copyright (C) Jaya Kumar
	4	*
	5	* Based on Jaroslav Kysela and Takashi Iwai's examples.
	6	* This work was sponsored by CIS(M) Sdn Bhd.
	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	* todo: add be fmt support, spdif, pm
	23	*/
	24
	25	#include <linux/init.h>
	26	#include <linux/slab.h>
	27	#include <linux/pci.h>
	28	#include <sound/driver.h>
	29	#include <sound/core.h>
	30	#include <sound/control.h>
	31	#include <sound/initval.h>
	32	#include <sound/asoundef.h>
	33	#include <sound/pcm.h>
	34	#include <sound/pcm_params.h>
	35	#include <sound/ac97_codec.h>
	36	#include "cs5535audio.h"
	37
66f8df6b	38	static struct snd_pcm_hardware snd_cs5535audio_playback =
9b4ffa48 JK	39	{
	40	.info = (
	41	SNDRV_PCM_INFO_MMAP \|
	42	SNDRV_PCM_INFO_INTERLEAVED \|
	43	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	44	SNDRV_PCM_INFO_MMAP_VALID \|
	45	SNDRV_PCM_INFO_PAUSE \|
9ac25594 JK	46	SNDRV_PCM_INFO_SYNC_START \|
9ac25594 JK	47	SNDRV_PCM_INFO_RESUME
9b4ffa48 JK	48	),
	49	.formats = (
	50	SNDRV_PCM_FMTBIT_S16_LE
	51	),
	52	.rates = (
	53	SNDRV_PCM_RATE_CONTINUOUS \|
	54	SNDRV_PCM_RATE_8000_48000
	55	),
	56	.rate_min = 4000,
	57	.rate_max = 48000,
	58	.channels_min = 2,
	59	.channels_max = 2,
	60	.buffer_bytes_max = (128*1024),
	61	.period_bytes_min = 64,
	62	.period_bytes_max = (64*1024 - 16),
	63	.periods_min = 1,
	64	.periods_max = CS5535AUDIO_MAX_DESCRIPTORS,
	65	.fifo_size = 0,
	66	};
	67
66f8df6b	68	static struct snd_pcm_hardware snd_cs5535audio_capture =
9b4ffa48 JK	69	{
	70	.info = (
	71	SNDRV_PCM_INFO_MMAP \|
	72	SNDRV_PCM_INFO_INTERLEAVED \|
	73	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	74	SNDRV_PCM_INFO_MMAP_VALID \|
	75	SNDRV_PCM_INFO_SYNC_START
	76	),
	77	.formats = (
	78	SNDRV_PCM_FMTBIT_S16_LE
	79	),
	80	.rates = (
	81	SNDRV_PCM_RATE_CONTINUOUS \|
	82	SNDRV_PCM_RATE_8000_48000
	83	),
	84	.rate_min = 4000,
	85	.rate_max = 48000,
	86	.channels_min = 2,
	87	.channels_max = 2,
	88	.buffer_bytes_max = (128*1024),
	89	.period_bytes_min = 64,
	90	.period_bytes_max = (64*1024 - 16),
	91	.periods_min = 1,
	92	.periods_max = CS5535AUDIO_MAX_DESCRIPTORS,
	93	.fifo_size = 0,
	94	};
	95
66f8df6b	96	static int snd_cs5535audio_playback_open(struct snd_pcm_substream *substream)
9b4ffa48 JK	97	{
9b4ffa48 JK	98	int err;
66f8df6b TI	99	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
66f8df6b TI	100	struct snd_pcm_runtime *runtime = substream->runtime;
9b4ffa48 JK	101
	102	runtime->hw = snd_cs5535audio_playback;
	103	cs5535au->playback_substream = substream;
	104	runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK]);
	105	snd_pcm_set_sync(substream);
	106	if ((err = snd_pcm_hw_constraint_integer(runtime,
	107	SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
	108	return err;
	109
	110	return 0;
	111	}
	112
66f8df6b	113	static int snd_cs5535audio_playback_close(struct snd_pcm_substream *substream)
9b4ffa48 JK	114	{
	115	return 0;
	116	}
	117
	118	#define CS5535AUDIO_DESC_LIST_SIZE \
66f8df6b	119	PAGE_ALIGN(CS5535AUDIO_MAX_DESCRIPTORS * sizeof(struct cs5535audio_dma_desc))
9b4ffa48	120
66f8df6b TI	121	static int cs5535audio_build_dma_packets(struct cs5535audio *cs5535au,
	122	struct cs5535audio_dma *dma,
	123	struct snd_pcm_substream *substream,
	124	unsigned int periods,
	125	unsigned int period_bytes)
9b4ffa48 JK	126	{
	127	unsigned int i;
	128	u32 addr, desc_addr, jmpprd_addr;
66f8df6b	129	struct cs5535audio_dma_desc *lastdesc;
9b4ffa48 JK	130
	131	if (periods > CS5535AUDIO_MAX_DESCRIPTORS)
	132	return -ENOMEM;
	133
	134	if (dma->desc_buf.area == NULL) {
	135	if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
	136	snd_dma_pci_data(cs5535au->pci),
	137	CS5535AUDIO_DESC_LIST_SIZE+1,
	138	&dma->desc_buf) < 0)
	139	return -ENOMEM;
	140	dma->period_bytes = dma->periods = 0;
	141	}
	142
	143	if (dma->periods == periods && dma->period_bytes == period_bytes)
	144	return 0;
	145
d6e05edc	146	/* the u32 cast is okay because in snd*create we successfully told
9b4ffa48 JK	147	pci alloc that we're only 32 bit capable so the uppper will be 0 */
	148	addr = (u32) substream->runtime->dma_addr;
	149	desc_addr = (u32) dma->desc_buf.addr;
	150	for (i = 0; i < periods; i++) {
66f8df6b TI	151	struct cs5535audio_dma_desc *desc =
66f8df6b TI	152	&((struct cs5535audio_dma_desc *) dma->desc_buf.area)[i];
9b4ffa48	153	desc->addr = cpu_to_le32(addr);
3e873174 TI	154	desc->size = cpu_to_le32(period_bytes);
3e873174 TI	155	desc->ctlreserved = cpu_to_le32(PRD_EOP);
66f8df6b	156	desc_addr += sizeof(struct cs5535audio_dma_desc);
9b4ffa48 JK	157	addr += period_bytes;
	158	}
	159	/* we reserved one dummy descriptor at the end to do the PRD jump */
66f8df6b	160	lastdesc = &((struct cs5535audio_dma_desc *) dma->desc_buf.area)[periods];
9b4ffa48 JK	161	lastdesc->addr = cpu_to_le32((u32) dma->desc_buf.addr);
9b4ffa48 JK	162	lastdesc->size = 0;
3e873174	163	lastdesc->ctlreserved = cpu_to_le32(PRD_JMP);
9b4ffa48	164	jmpprd_addr = cpu_to_le32(lastdesc->addr +
66f8df6b	165	(sizeof(struct cs5535audio_dma_desc)*periods));
9b4ffa48 JK	166
	167	dma->period_bytes = period_bytes;
	168	dma->periods = periods;
	169	spin_lock_irq(&cs5535au->reg_lock);
	170	dma->ops->disable_dma(cs5535au);
	171	dma->ops->setup_prd(cs5535au, jmpprd_addr);
	172	spin_unlock_irq(&cs5535au->reg_lock);
	173	return 0;
	174	}
	175
66f8df6b	176	static void cs5535audio_playback_enable_dma(struct cs5535audio *cs5535au)
9b4ffa48 JK	177	{
	178	cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_EN);
	179	}
	180
66f8df6b	181	static void cs5535audio_playback_disable_dma(struct cs5535audio *cs5535au)
9b4ffa48 JK	182	{
	183	cs_writeb(cs5535au, ACC_BM0_CMD, 0);
	184	}
	185
66f8df6b	186	static void cs5535audio_playback_pause_dma(struct cs5535audio *cs5535au)
9b4ffa48 JK	187	{
	188	cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_PAUSE);
	189	}
	190
66f8df6b TI	191	static void cs5535audio_playback_setup_prd(struct cs5535audio *cs5535au,
66f8df6b TI	192	u32 prd_addr)
9b4ffa48 JK	193	{
	194	cs_writel(cs5535au, ACC_BM0_PRD, prd_addr);
	195	}
	196
9ac25594 JK	197	static u32 cs5535audio_playback_read_prd(struct cs5535audio *cs5535au)
	198	{
	199	return cs_readl(cs5535au, ACC_BM0_PRD);
	200	}
	201
66f8df6b	202	static u32 cs5535audio_playback_read_dma_pntr(struct cs5535audio *cs5535au)
9b4ffa48 JK	203	{
	204	return cs_readl(cs5535au, ACC_BM0_PNTR);
	205	}
	206
66f8df6b	207	static void cs5535audio_capture_enable_dma(struct cs5535audio *cs5535au)
9b4ffa48 JK	208	{
	209	cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_EN);
	210	}
	211
66f8df6b	212	static void cs5535audio_capture_disable_dma(struct cs5535audio *cs5535au)
9b4ffa48 JK	213	{
	214	cs_writeb(cs5535au, ACC_BM1_CMD, 0);
	215	}
	216
66f8df6b	217	static void cs5535audio_capture_pause_dma(struct cs5535audio *cs5535au)
9b4ffa48 JK	218	{
	219	cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_PAUSE);
	220	}
	221
66f8df6b TI	222	static void cs5535audio_capture_setup_prd(struct cs5535audio *cs5535au,
66f8df6b TI	223	u32 prd_addr)
9b4ffa48 JK	224	{
	225	cs_writel(cs5535au, ACC_BM1_PRD, prd_addr);
	226	}
	227
9ac25594 JK	228	static u32 cs5535audio_capture_read_prd(struct cs5535audio *cs5535au)
	229	{
	230	return cs_readl(cs5535au, ACC_BM1_PRD);
	231	}
	232
66f8df6b	233	static u32 cs5535audio_capture_read_dma_pntr(struct cs5535audio *cs5535au)
9b4ffa48 JK	234	{
	235	return cs_readl(cs5535au, ACC_BM1_PNTR);
	236	}
	237
66f8df6b TI	238	static void cs5535audio_clear_dma_packets(struct cs5535audio *cs5535au,
	239	struct cs5535audio_dma *dma,
	240	struct snd_pcm_substream *substream)
9b4ffa48 JK	241	{
	242	snd_dma_free_pages(&dma->desc_buf);
	243	dma->desc_buf.area = NULL;
	244	}
	245
66f8df6b TI	246	static int snd_cs5535audio_hw_params(struct snd_pcm_substream *substream,
66f8df6b TI	247	struct snd_pcm_hw_params *hw_params)
9b4ffa48	248	{
66f8df6b TI	249	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
66f8df6b TI	250	struct cs5535audio_dma *dma = substream->runtime->private_data;
9b4ffa48 JK	251	int err;
	252
	253	err = snd_pcm_lib_malloc_pages(substream,
	254	params_buffer_bytes(hw_params));
	255	if (err < 0)
	256	return err;
	257	dma->buf_addr = substream->runtime->dma_addr;
	258	dma->buf_bytes = params_buffer_bytes(hw_params);
	259
	260	err = cs5535audio_build_dma_packets(cs5535au, dma, substream,
66f8df6b TI	261	params_periods(hw_params),
66f8df6b TI	262	params_period_bytes(hw_params));
9b4ffa48 JK	263	return err;
	264	}
	265
66f8df6b	266	static int snd_cs5535audio_hw_free(struct snd_pcm_substream *substream)
9b4ffa48	267	{
66f8df6b TI	268	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
66f8df6b TI	269	struct cs5535audio_dma *dma = substream->runtime->private_data;
9b4ffa48 JK	270
	271	cs5535audio_clear_dma_packets(cs5535au, dma, substream);
	272	return snd_pcm_lib_free_pages(substream);
	273	}
	274
66f8df6b	275	static int snd_cs5535audio_playback_prepare(struct snd_pcm_substream *substream)
9b4ffa48	276	{
66f8df6b	277	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
9b4ffa48	278	return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_FRONT_DAC_RATE,
66f8df6b	279	substream->runtime->rate);
9b4ffa48 JK	280	}
9b4ffa48 JK	281
66f8df6b	282	static int snd_cs5535audio_trigger(struct snd_pcm_substream *substream, int cmd)
9b4ffa48	283	{
66f8df6b TI	284	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
66f8df6b TI	285	struct cs5535audio_dma *dma = substream->runtime->private_data;
3e873174	286	int err = 0;
9b4ffa48	287
3e873174	288	spin_lock(&cs5535au->reg_lock);
9b4ffa48	289	switch (cmd) {
3e873174 TI	290	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	291	dma->ops->pause_dma(cs5535au);
	292	break;
	293	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	294	dma->ops->enable_dma(cs5535au);
	295	break;
	296	case SNDRV_PCM_TRIGGER_START:
	297	dma->ops->enable_dma(cs5535au);
	298	break;
9ac25594 JK	299	case SNDRV_PCM_TRIGGER_RESUME:
	300	dma->ops->enable_dma(cs5535au);
	301	dma->suspended = 0;
	302	break;
3e873174 TI	303	case SNDRV_PCM_TRIGGER_STOP:
	304	dma->ops->disable_dma(cs5535au);
	305	break;
9ac25594 JK	306	case SNDRV_PCM_TRIGGER_SUSPEND:
	307	dma->ops->disable_dma(cs5535au);
	308	dma->suspended = 1;
	309	break;
3e873174 TI	310	default:
	311	snd_printk(KERN_ERR "unhandled trigger\n");
	312	err = -EINVAL;
	313	break;
9b4ffa48	314	}
3e873174 TI	315	spin_unlock(&cs5535au->reg_lock);
3e873174 TI	316	return err;
9b4ffa48 JK	317	}
9b4ffa48 JK	318
66f8df6b	319	static snd_pcm_uframes_t snd_cs5535audio_pcm_pointer(struct snd_pcm_substream
9b4ffa48 JK	320	*substream)
9b4ffa48 JK	321	{
66f8df6b	322	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
9b4ffa48	323	u32 curdma;
66f8df6b	324	struct cs5535audio_dma *dma;
9b4ffa48 JK	325
	326	dma = substream->runtime->private_data;
	327	curdma = dma->ops->read_dma_pntr(cs5535au);
	328	if (curdma < dma->buf_addr) {
	329	snd_printk(KERN_ERR "curdma=%x < %x bufaddr.\n",
	330	curdma, dma->buf_addr);
	331	return 0;
	332	}
	333	curdma -= dma->buf_addr;
	334	if (curdma >= dma->buf_bytes) {
	335	snd_printk(KERN_ERR "diff=%x >= %x buf_bytes.\n",
	336	curdma, dma->buf_bytes);
	337	return 0;
	338	}
	339	return bytes_to_frames(substream->runtime, curdma);
	340	}
	341
66f8df6b	342	static int snd_cs5535audio_capture_open(struct snd_pcm_substream *substream)
9b4ffa48 JK	343	{
9b4ffa48 JK	344	int err;
66f8df6b TI	345	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
66f8df6b TI	346	struct snd_pcm_runtime *runtime = substream->runtime;
9b4ffa48 JK	347
	348	runtime->hw = snd_cs5535audio_capture;
	349	cs5535au->capture_substream = substream;
	350	runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE]);
	351	snd_pcm_set_sync(substream);
	352	if ((err = snd_pcm_hw_constraint_integer(runtime,
	353	SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
	354	return err;
	355	return 0;
	356	}
	357
66f8df6b	358	static int snd_cs5535audio_capture_close(struct snd_pcm_substream *substream)
9b4ffa48 JK	359	{
	360	return 0;
	361	}
	362
66f8df6b	363	static int snd_cs5535audio_capture_prepare(struct snd_pcm_substream *substream)
9b4ffa48	364	{
66f8df6b	365	struct cs5535audio *cs5535au = snd_pcm_substream_chip(substream);
9b4ffa48	366	return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_LR_ADC_RATE,
66f8df6b	367	substream->runtime->rate);
9b4ffa48 JK	368	}
9b4ffa48 JK	369
66f8df6b	370	static struct snd_pcm_ops snd_cs5535audio_playback_ops = {
9b4ffa48 JK	371	.open = snd_cs5535audio_playback_open,
	372	.close = snd_cs5535audio_playback_close,
	373	.ioctl = snd_pcm_lib_ioctl,
	374	.hw_params = snd_cs5535audio_hw_params,
	375	.hw_free = snd_cs5535audio_hw_free,
	376	.prepare = snd_cs5535audio_playback_prepare,
	377	.trigger = snd_cs5535audio_trigger,
	378	.pointer = snd_cs5535audio_pcm_pointer,
	379	};
	380
66f8df6b	381	static struct snd_pcm_ops snd_cs5535audio_capture_ops = {
9b4ffa48 JK	382	.open = snd_cs5535audio_capture_open,
	383	.close = snd_cs5535audio_capture_close,
	384	.ioctl = snd_pcm_lib_ioctl,
	385	.hw_params = snd_cs5535audio_hw_params,
	386	.hw_free = snd_cs5535audio_hw_free,
	387	.prepare = snd_cs5535audio_capture_prepare,
	388	.trigger = snd_cs5535audio_trigger,
	389	.pointer = snd_cs5535audio_pcm_pointer,
	390	};
	391
66f8df6b	392	static struct cs5535audio_dma_ops snd_cs5535audio_playback_dma_ops = {
9b4ffa48 JK	393	.type = CS5535AUDIO_DMA_PLAYBACK,
	394	.enable_dma = cs5535audio_playback_enable_dma,
	395	.disable_dma = cs5535audio_playback_disable_dma,
	396	.setup_prd = cs5535audio_playback_setup_prd,
9ac25594	397	.read_prd = cs5535audio_playback_read_prd,
9b4ffa48 JK	398	.pause_dma = cs5535audio_playback_pause_dma,
	399	.read_dma_pntr = cs5535audio_playback_read_dma_pntr,
	400	};
	401
66f8df6b	402	static struct cs5535audio_dma_ops snd_cs5535audio_capture_dma_ops = {
9b4ffa48 JK	403	.type = CS5535AUDIO_DMA_CAPTURE,
	404	.enable_dma = cs5535audio_capture_enable_dma,
	405	.disable_dma = cs5535audio_capture_disable_dma,
	406	.setup_prd = cs5535audio_capture_setup_prd,
9ac25594	407	.read_prd = cs5535audio_capture_read_prd,
9b4ffa48 JK	408	.pause_dma = cs5535audio_capture_pause_dma,
	409	.read_dma_pntr = cs5535audio_capture_read_dma_pntr,
	410	};
	411
66f8df6b	412	int __devinit snd_cs5535audio_pcm(struct cs5535audio *cs5535au)
9b4ffa48	413	{
66f8df6b	414	struct snd_pcm *pcm;
9b4ffa48 JK	415	int err;
	416
	417	err = snd_pcm_new(cs5535au->card, "CS5535 Audio", 0, 1, 1, &pcm);
	418	if (err < 0)
	419	return err;
	420
	421	cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK].ops =
	422	&snd_cs5535audio_playback_dma_ops;
	423	cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE].ops =
	424	&snd_cs5535audio_capture_dma_ops;
	425	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
	426	&snd_cs5535audio_playback_ops);
	427	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
	428	&snd_cs5535audio_capture_ops);
	429
	430	pcm->private_data = cs5535au;
9b4ffa48 JK	431	pcm->info_flags = 0;
	432	strcpy(pcm->name, "CS5535 Audio");
	433
	434	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
	435	snd_dma_pci_data(cs5535au->pci),
	436	641024, 1281024);
9ac25594	437	cs5535au->pcm = pcm;
9b4ffa48 JK	438
	439	return 0;
	440	}
	441