[linux-2.6-block.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/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_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
				),
	.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;
	runtime->hw.rates = cs5535au->ac97->rates[AC97_RATES_FRONT_DAC];
	snd_pcm_limit_hw_rates(runtime);
	cs5535au->playback_substream = substream;
	runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK]);
	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->substream = substream;
	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;
	dma->substream = 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));
	if (!err)
		dma->pcm_open_flag = 1;

	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;

	if (dma->pcm_open_flag) {
		if (substream == cs5535au->playback_substream)
			snd_ac97_update_power(cs5535au->ac97,
					AC97_PCM_FRONT_DAC_RATE, 0);
		else
			snd_ac97_update_power(cs5535au->ac97,
					AC97_PCM_LR_ADC_RATE, 0);
		dma->pcm_open_flag = 0;
	}
	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);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		dma->ops->disable_dma(cs5535au);
		break;
	case SNDRV_PCM_TRIGGER_SUSPEND:
		dma->ops->disable_dma(cs5535au);
		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;
	runtime->hw.rates = cs5535au->ac97->rates[AC97_RATES_ADC];
	snd_pcm_limit_hw_rates(runtime);
	cs5535au->capture_substream = substream;
	runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE]);
	if ((err = snd_pcm_hw_constraint_integer(runtime,
					 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
		return err;
	olpc_capture_open(cs5535au->ac97);
	return 0;
}

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