[deliverable/linux.git] / drivers / media / pci / cx23885 / cx23885-alsa.c

/*
 *
 *  Support for CX23885 analog audio capture
 *
 *    (c) 2008 Mijhail Moreyra <mijhail.moreyra@gmail.com>
 *    Adapted from cx88-alsa.c
 *    (c) 2009 Steven Toth <stoth@kernellabs.com>
 *
 *  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.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/vmalloc.h>
#include <linux/dma-mapping.h>
#include <linux/pci.h>

#include <asm/delay.h>

#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/control.h>
#include <sound/initval.h>

#include <sound/tlv.h>


#include "cx23885.h"
#include "cx23885-reg.h"

#define AUDIO_SRAM_CHANNEL	SRAM_CH07

#define dprintk(level, fmt, arg...) do {				\
	if (audio_debug + 1 > level)					\
		printk(KERN_INFO "%s: " fmt, chip->dev->name , ## arg);	\
} while(0)

#define dprintk_core(level, fmt, arg...)	if (audio_debug >= level) \
	printk(KERN_DEBUG "%s: " fmt, chip->dev->name , ## arg)

/****************************************************************************
			Module global static vars
 ****************************************************************************/

static unsigned int disable_analog_audio;
module_param(disable_analog_audio, int, 0644);
MODULE_PARM_DESC(disable_analog_audio, "disable analog audio ALSA driver");

static unsigned int audio_debug;
module_param(audio_debug, int, 0644);
MODULE_PARM_DESC(audio_debug, "enable debug messages [analog audio]");

/****************************************************************************
			Board specific funtions
 ****************************************************************************/

/* Constants taken from cx88-reg.h */
#define AUD_INT_DN_RISCI1       (1 <<  0)
#define AUD_INT_UP_RISCI1       (1 <<  1)
#define AUD_INT_RDS_DN_RISCI1   (1 <<  2)
#define AUD_INT_DN_RISCI2       (1 <<  4) /* yes, 3 is skipped */
#define AUD_INT_UP_RISCI2       (1 <<  5)
#define AUD_INT_RDS_DN_RISCI2   (1 <<  6)
#define AUD_INT_DN_SYNC         (1 << 12)
#define AUD_INT_UP_SYNC         (1 << 13)
#define AUD_INT_RDS_DN_SYNC     (1 << 14)
#define AUD_INT_OPC_ERR         (1 << 16)
#define AUD_INT_BER_IRQ         (1 << 20)
#define AUD_INT_MCHG_IRQ        (1 << 21)
#define GP_COUNT_CONTROL_RESET	0x3

static int cx23885_alsa_dma_init(struct cx23885_audio_dev *chip, int nr_pages)
{
	struct cx23885_audio_buffer *buf = chip->buf;
	struct page *pg;
	int i;

	buf->vaddr = vmalloc_32(nr_pages << PAGE_SHIFT);
	if (NULL == buf->vaddr) {
		dprintk(1, "vmalloc_32(%d pages) failed\n", nr_pages);
		return -ENOMEM;
	}

	dprintk(1, "vmalloc is at addr 0x%08lx, size=%d\n",
				(unsigned long)buf->vaddr,
				nr_pages << PAGE_SHIFT);

	memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT);
	buf->nr_pages = nr_pages;

	buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist));
	if (NULL == buf->sglist)
		goto vzalloc_err;

	sg_init_table(buf->sglist, buf->nr_pages);
	for (i = 0; i < buf->nr_pages; i++) {
		pg = vmalloc_to_page(buf->vaddr + i * PAGE_SIZE);
		if (NULL == pg)
			goto vmalloc_to_page_err;
		sg_set_page(&buf->sglist[i], pg, PAGE_SIZE, 0);
	}
	return 0;

vmalloc_to_page_err:
	vfree(buf->sglist);
	buf->sglist = NULL;
vzalloc_err:
	vfree(buf->vaddr);
	buf->vaddr = NULL;
	return -ENOMEM;
}

static int cx23885_alsa_dma_map(struct cx23885_audio_dev *dev)
{
	struct cx23885_audio_buffer *buf = dev->buf;

	buf->sglen = dma_map_sg(&dev->pci->dev, buf->sglist,
			buf->nr_pages, PCI_DMA_FROMDEVICE);

	if (0 == buf->sglen) {
		pr_warn("%s: cx23885_alsa_map_sg failed\n", __func__);
		return -ENOMEM;
	}
	return 0;
}

static int cx23885_alsa_dma_unmap(struct cx23885_audio_dev *dev)
{
	struct cx23885_audio_buffer *buf = dev->buf;

	if (!buf->sglen)
		return 0;

	dma_unmap_sg(&dev->pci->dev, buf->sglist, buf->sglen, PCI_DMA_FROMDEVICE);
	buf->sglen = 0;
	return 0;
}

static int cx23885_alsa_dma_free(struct cx23885_audio_buffer *buf)
{
	vfree(buf->sglist);
	buf->sglist = NULL;
	vfree(buf->vaddr);
	buf->vaddr = NULL;
	return 0;
}

/*
 * BOARD Specific: Sets audio DMA
 */

static int cx23885_start_audio_dma(struct cx23885_audio_dev *chip)
{
	struct cx23885_audio_buffer *buf = chip->buf;
	struct cx23885_dev *dev  = chip->dev;
	struct sram_channel *audio_ch =
		&dev->sram_channels[AUDIO_SRAM_CHANNEL];

	dprintk(1, "%s()\n", __func__);

	/* Make sure RISC/FIFO are off before changing FIFO/RISC settings */
	cx_clear(AUD_INT_DMA_CTL, 0x11);

	/* setup fifo + format - out channel */
	cx23885_sram_channel_setup(chip->dev, audio_ch, buf->bpl,
		buf->risc.dma);

	/* sets bpl size */
	cx_write(AUD_INT_A_LNGTH, buf->bpl);

	/* This is required to get good audio (1 seems to be ok) */
	cx_write(AUD_INT_A_MODE, 1);

	/* reset counter */
	cx_write(AUD_INT_A_GPCNT_CTL, GP_COUNT_CONTROL_RESET);
	atomic_set(&chip->count, 0);

	dprintk(1, "Start audio DMA, %d B/line, %d lines/FIFO, %d periods, %d "
		"byte buffer\n", buf->bpl, cx_read(audio_ch->cmds_start+12)>>1,
		chip->num_periods, buf->bpl * chip->num_periods);

	/* Enables corresponding bits at AUD_INT_STAT */
	cx_write(AUDIO_INT_INT_MSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC |
				    AUD_INT_DN_RISCI1);

	/* Clean any pending interrupt bits already set */
	cx_write(AUDIO_INT_INT_STAT, ~0);

	/* enable audio irqs */
	cx_set(PCI_INT_MSK, chip->dev->pci_irqmask | PCI_MSK_AUD_INT);

	/* start dma */
	cx_set(DEV_CNTRL2, (1<<5)); /* Enables Risc Processor */
	cx_set(AUD_INT_DMA_CTL, 0x11); /* audio downstream FIFO and
					  RISC enable */
	if (audio_debug)
		cx23885_sram_channel_dump(chip->dev, audio_ch);

	return 0;
}

/*
 * BOARD Specific: Resets audio DMA
 */
static int cx23885_stop_audio_dma(struct cx23885_audio_dev *chip)
{
	struct cx23885_dev *dev = chip->dev;
	dprintk(1, "Stopping audio DMA\n");

	/* stop dma */
	cx_clear(AUD_INT_DMA_CTL, 0x11);

	/* disable irqs */
	cx_clear(PCI_INT_MSK, PCI_MSK_AUD_INT);
	cx_clear(AUDIO_INT_INT_MSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC |
				    AUD_INT_DN_RISCI1);

	if (audio_debug)
		cx23885_sram_channel_dump(chip->dev,
			&dev->sram_channels[AUDIO_SRAM_CHANNEL]);

	return 0;
}

/*
 * BOARD Specific: Handles audio IRQ
 */
int cx23885_audio_irq(struct cx23885_dev *dev, u32 status, u32 mask)
{
	struct cx23885_audio_dev *chip = dev->audio_dev;

	if (0 == (status & mask))
		return 0;

	cx_write(AUDIO_INT_INT_STAT, status);

	/* risc op code error */
	if (status & AUD_INT_OPC_ERR) {
		printk(KERN_WARNING "%s/1: Audio risc op code error\n",
			dev->name);
		cx_clear(AUD_INT_DMA_CTL, 0x11);
		cx23885_sram_channel_dump(dev,
			&dev->sram_channels[AUDIO_SRAM_CHANNEL]);
	}
	if (status & AUD_INT_DN_SYNC) {
		dprintk(1, "Downstream sync error\n");
		cx_write(AUD_INT_A_GPCNT_CTL, GP_COUNT_CONTROL_RESET);
		return 1;
	}
	/* risc1 downstream */
	if (status & AUD_INT_DN_RISCI1) {
		atomic_set(&chip->count, cx_read(AUD_INT_A_GPCNT));
		snd_pcm_period_elapsed(chip->substream);
	}
	/* FIXME: Any other status should deserve a special handling? */

	return 1;
}

static int dsp_buffer_free(struct cx23885_audio_dev *chip)
{
	struct cx23885_riscmem *risc;

	BUG_ON(!chip->dma_size);

	dprintk(2, "Freeing buffer\n");
	cx23885_alsa_dma_unmap(chip);
	cx23885_alsa_dma_free(chip->buf);
	risc = &chip->buf->risc;
	pci_free_consistent(chip->pci, risc->size, risc->cpu, risc->dma);
	kfree(chip->buf);

	chip->buf = NULL;
	chip->dma_size = 0;

	return 0;
}

/****************************************************************************
				ALSA PCM Interface
 ****************************************************************************/

/*
 * Digital hardware definition
 */
#define DEFAULT_FIFO_SIZE	4096

static struct snd_pcm_hardware snd_cx23885_digital_hw = {
	.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_48000,
	.rate_min =		48000,
	.rate_max =		48000,
	.channels_min = 2,
	.channels_max = 2,
	/* Analog audio output will be full of clicks and pops if there
	   are not exactly four lines in the SRAM FIFO buffer.  */
	.period_bytes_min = DEFAULT_FIFO_SIZE/4,
	.period_bytes_max = DEFAULT_FIFO_SIZE/4,
	.periods_min = 1,
	.periods_max = 1024,
	.buffer_bytes_max = (1024*1024),
};

/*
 * audio pcm capture open callback
 */
static int snd_cx23885_pcm_open(struct snd_pcm_substream *substream)
{
	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	int err;

	if (!chip) {
		printk(KERN_ERR "BUG: cx23885 can't find device struct."
				" Can't proceed with open\n");
		return -ENODEV;
	}

	err = snd_pcm_hw_constraint_pow2(runtime, 0,
		SNDRV_PCM_HW_PARAM_PERIODS);
	if (err < 0)
		goto _error;

	chip->substream = substream;

	runtime->hw = snd_cx23885_digital_hw;

	if (chip->dev->sram_channels[AUDIO_SRAM_CHANNEL].fifo_size !=
		DEFAULT_FIFO_SIZE) {
		unsigned int bpl = chip->dev->
			sram_channels[AUDIO_SRAM_CHANNEL].fifo_size / 4;
		bpl &= ~7; /* must be multiple of 8 */
		runtime->hw.period_bytes_min = bpl;
		runtime->hw.period_bytes_max = bpl;
	}

	return 0;
_error:
	dprintk(1, "Error opening PCM!\n");
	return err;
}

/*
 * audio close callback
 */
static int snd_cx23885_close(struct snd_pcm_substream *substream)
{
	return 0;
}


/*
 * hw_params callback
 */
static int snd_cx23885_hw_params(struct snd_pcm_substream *substream,
			      struct snd_pcm_hw_params *hw_params)
{
	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	struct cx23885_audio_buffer *buf;
	int ret;

	if (substream->runtime->dma_area) {
		dsp_buffer_free(chip);
		substream->runtime->dma_area = NULL;
	}

	chip->period_size = params_period_bytes(hw_params);
	chip->num_periods = params_periods(hw_params);
	chip->dma_size = chip->period_size * params_periods(hw_params);

	BUG_ON(!chip->dma_size);
	BUG_ON(chip->num_periods & (chip->num_periods-1));

	buf = kzalloc(sizeof(*buf), GFP_KERNEL);
	if (NULL == buf)
		return -ENOMEM;

	buf->bpl = chip->period_size;
	chip->buf = buf;

	ret = cx23885_alsa_dma_init(chip,
			(PAGE_ALIGN(chip->dma_size) >> PAGE_SHIFT));
	if (ret < 0)
		goto error;

	ret = cx23885_alsa_dma_map(chip);
	if (ret < 0)
		goto error;

	ret = cx23885_risc_databuffer(chip->pci, &buf->risc, buf->sglist,
				   chip->period_size, chip->num_periods, 1);
	if (ret < 0)
		goto error;

	/* Loop back to start of program */
	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP|RISC_IRQ1|RISC_CNT_INC);
	buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
	buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */

	substream->runtime->dma_area = chip->buf->vaddr;
	substream->runtime->dma_bytes = chip->dma_size;
	substream->runtime->dma_addr = 0;

	return 0;

error:
	kfree(buf);
	chip->buf = NULL;
	return ret;
}

/*
 * hw free callback
 */
static int snd_cx23885_hw_free(struct snd_pcm_substream *substream)
{

	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);

	if (substream->runtime->dma_area) {
		dsp_buffer_free(chip);
		substream->runtime->dma_area = NULL;
	}

	return 0;
}

/*
 * prepare callback
 */
static int snd_cx23885_prepare(struct snd_pcm_substream *substream)
{
	return 0;
}

/*
 * trigger callback
 */
static int snd_cx23885_card_trigger(struct snd_pcm_substream *substream,
	int cmd)
{
	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	int err;

	/* Local interrupts are already disabled by ALSA */
	spin_lock(&chip->lock);

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		err = cx23885_start_audio_dma(chip);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		err = cx23885_stop_audio_dma(chip);
		break;
	default:
		err = -EINVAL;
		break;
	}

	spin_unlock(&chip->lock);

	return err;
}

/*
 * pointer callback
 */
static snd_pcm_uframes_t snd_cx23885_pointer(
	struct snd_pcm_substream *substream)
{
	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	u16 count;

	count = atomic_read(&chip->count);

	return runtime->period_size * (count & (runtime->periods-1));
}

/*
 * page callback (needed for mmap)
 */
static struct page *snd_cx23885_page(struct snd_pcm_substream *substream,
				unsigned long offset)
{
	void *pageptr = substream->runtime->dma_area + offset;
	return vmalloc_to_page(pageptr);
}

/*
 * operators
 */
static struct snd_pcm_ops snd_cx23885_pcm_ops = {
	.open = snd_cx23885_pcm_open,
	.close = snd_cx23885_close,
	.ioctl = snd_pcm_lib_ioctl,
	.hw_params = snd_cx23885_hw_params,
	.hw_free = snd_cx23885_hw_free,
	.prepare = snd_cx23885_prepare,
	.trigger = snd_cx23885_card_trigger,
	.pointer = snd_cx23885_pointer,
	.page = snd_cx23885_page,
};

/*
 * create a PCM device
 */
static int snd_cx23885_pcm(struct cx23885_audio_dev *chip, int device,
	char *name)
{
	int err;
	struct snd_pcm *pcm;

	err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm);
	if (err < 0)
		return err;
	pcm->private_data = chip;
	strcpy(pcm->name, name);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cx23885_pcm_ops);

	return 0;
}

/****************************************************************************
			Basic Flow for Sound Devices
 ****************************************************************************/

/*
 * Alsa Constructor - Component probe
 */

struct cx23885_audio_dev *cx23885_audio_register(struct cx23885_dev *dev)
{
	struct snd_card *card;
	struct cx23885_audio_dev *chip;
	int err;

	if (disable_analog_audio)
		return NULL;

	if (dev->sram_channels[AUDIO_SRAM_CHANNEL].cmds_start == 0) {
		printk(KERN_WARNING "%s(): Missing SRAM channel configuration "
			"for analog TV Audio\n", __func__);
		return NULL;
	}

	err = snd_card_new(&dev->pci->dev,
			   SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
			THIS_MODULE, sizeof(struct cx23885_audio_dev), &card);
	if (err < 0)
		goto error;

	chip = (struct cx23885_audio_dev *) card->private_data;
	chip->dev = dev;
	chip->pci = dev->pci;
	chip->card = card;
	spin_lock_init(&chip->lock);

	err = snd_cx23885_pcm(chip, 0, "CX23885 Digital");
	if (err < 0)
		goto error;

	strcpy(card->driver, "CX23885");
	sprintf(card->shortname, "Conexant CX23885");
	sprintf(card->longname, "%s at %s", card->shortname, dev->name);

	err = snd_card_register(card);
	if (err < 0)
		goto error;

	dprintk(0, "registered ALSA audio device\n");

	return chip;

error:
	snd_card_free(card);
	printk(KERN_ERR "%s(): Failed to register analog "
			"audio adapter\n", __func__);

	return NULL;
}

/*
 * ALSA destructor
 */
void cx23885_audio_unregister(struct cx23885_dev *dev)
{
	struct cx23885_audio_dev *chip = dev->audio_dev;

	snd_card_free(chip->card);
}
Commit	Line	Data
9e44d632 MM	1	/*
	2	*
	3	* Support for CX23885 analog audio capture
	4	*
	5	* (c) 2008 Mijhail Moreyra <mijhail.moreyra@gmail.com>
	6	* Adapted from cx88-alsa.c
	7	* (c) 2009 Steven Toth <stoth@kernellabs.com>
	8	*
	9	* This program is free software; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
9e44d632 MM	18	*/
	19
	20	#include <linux/module.h>
	21	#include <linux/init.h>
	22	#include <linux/device.h>
	23	#include <linux/interrupt.h>
	24	#include <linux/vmalloc.h>
	25	#include <linux/dma-mapping.h>
	26	#include <linux/pci.h>
	27
	28	#include <asm/delay.h>
	29
	30	#include <sound/core.h>
	31	#include <sound/pcm.h>
	32	#include <sound/pcm_params.h>
	33	#include <sound/control.h>
	34	#include <sound/initval.h>
	35
	36	#include <sound/tlv.h>
	37
	38
	39	#include "cx23885.h"
	40	#include "cx23885-reg.h"
	41
	42	#define AUDIO_SRAM_CHANNEL SRAM_CH07
	43
a041e103 MCC	44	#define dprintk(level, fmt, arg...) do { \
	45	if (audio_debug + 1 > level) \
	46	printk(KERN_INFO "%s: " fmt, chip->dev->name , ## arg); \
	47	} while(0)
9e44d632 MM	48
9e44d632 MM	49	#define dprintk_core(level, fmt, arg...) if (audio_debug >= level) \
b5f74050	50	printk(KERN_DEBUG "%s: " fmt, chip->dev->name , ## arg)
9e44d632 MM	51
	52	/****************************************************************************
	53	Module global static vars
	54	****************************************************************************/
	55
	56	static unsigned int disable_analog_audio;
	57	module_param(disable_analog_audio, int, 0644);
	58	MODULE_PARM_DESC(disable_analog_audio, "disable analog audio ALSA driver");
	59
	60	static unsigned int audio_debug;
	61	module_param(audio_debug, int, 0644);
	62	MODULE_PARM_DESC(audio_debug, "enable debug messages [analog audio]");
	63
	64	/****************************************************************************
	65	Board specific funtions
	66	****************************************************************************/
	67
	68	/* Constants taken from cx88-reg.h */
	69	#define AUD_INT_DN_RISCI1 (1 << 0)
	70	#define AUD_INT_UP_RISCI1 (1 << 1)
	71	#define AUD_INT_RDS_DN_RISCI1 (1 << 2)
	72	#define AUD_INT_DN_RISCI2 (1 << 4) /* yes, 3 is skipped */
	73	#define AUD_INT_UP_RISCI2 (1 << 5)
	74	#define AUD_INT_RDS_DN_RISCI2 (1 << 6)
	75	#define AUD_INT_DN_SYNC (1 << 12)
	76	#define AUD_INT_UP_SYNC (1 << 13)
	77	#define AUD_INT_RDS_DN_SYNC (1 << 14)
	78	#define AUD_INT_OPC_ERR (1 << 16)
	79	#define AUD_INT_BER_IRQ (1 << 20)
	80	#define AUD_INT_MCHG_IRQ (1 << 21)
	81	#define GP_COUNT_CONTROL_RESET 0x3
	82
9529a4b0 HV	83	static int cx23885_alsa_dma_init(struct cx23885_audio_dev *chip, int nr_pages)
	84	{
	85	struct cx23885_audio_buffer *buf = chip->buf;
	86	struct page *pg;
	87	int i;
	88
	89	buf->vaddr = vmalloc_32(nr_pages << PAGE_SHIFT);
	90	if (NULL == buf->vaddr) {
	91	dprintk(1, "vmalloc_32(%d pages) failed\n", nr_pages);
	92	return -ENOMEM;
	93	}
	94
	95	dprintk(1, "vmalloc is at addr 0x%08lx, size=%d\n",
	96	(unsigned long)buf->vaddr,
	97	nr_pages << PAGE_SHIFT);
	98
	99	memset(buf->vaddr, 0, nr_pages << PAGE_SHIFT);
	100	buf->nr_pages = nr_pages;
	101
	102	buf->sglist = vzalloc(buf->nr_pages * sizeof(*buf->sglist));
	103	if (NULL == buf->sglist)
	104	goto vzalloc_err;
	105
	106	sg_init_table(buf->sglist, buf->nr_pages);
	107	for (i = 0; i < buf->nr_pages; i++) {
	108	pg = vmalloc_to_page(buf->vaddr + i * PAGE_SIZE);
	109	if (NULL == pg)
	110	goto vmalloc_to_page_err;
	111	sg_set_page(&buf->sglist[i], pg, PAGE_SIZE, 0);
	112	}
	113	return 0;
	114
	115	vmalloc_to_page_err:
	116	vfree(buf->sglist);
	117	buf->sglist = NULL;
	118	vzalloc_err:
	119	vfree(buf->vaddr);
	120	buf->vaddr = NULL;
	121	return -ENOMEM;
	122	}
	123
	124	static int cx23885_alsa_dma_map(struct cx23885_audio_dev *dev)
	125	{
	126	struct cx23885_audio_buffer *buf = dev->buf;
	127
	128	buf->sglen = dma_map_sg(&dev->pci->dev, buf->sglist,
	129	buf->nr_pages, PCI_DMA_FROMDEVICE);
	130
	131	if (0 == buf->sglen) {
	132	pr_warn("%s: cx23885_alsa_map_sg failed\n", __func__);
	133	return -ENOMEM;
	134	}
	135	return 0;
	136	}
	137
	138	static int cx23885_alsa_dma_unmap(struct cx23885_audio_dev *dev)
	139	{
	140	struct cx23885_audio_buffer *buf = dev->buf;
	141
	142	if (!buf->sglen)
	143	return 0;
	144
	145	dma_unmap_sg(&dev->pci->dev, buf->sglist, buf->sglen, PCI_DMA_FROMDEVICE);
	146	buf->sglen = 0;
147	return 0;
148	}
149
150	static int cx23885_alsa_dma_free(struct cx23885_audio_buffer *buf)
151	{
152	vfree(buf->sglist);
153	buf->sglist = NULL;
154	vfree(buf->vaddr);
155	buf->vaddr = NULL;
156	return 0;
157	}
158
9e44d632 MM	159	/*
	160	* BOARD Specific: Sets audio DMA
	161	*/
	162
	163	static int cx23885_start_audio_dma(struct cx23885_audio_dev *chip)
	164	{
	165	struct cx23885_audio_buffer *buf = chip->buf;
	166	struct cx23885_dev *dev = chip->dev;
	167	struct sram_channel *audio_ch =
	168	&dev->sram_channels[AUDIO_SRAM_CHANNEL];
	169
	170	dprintk(1, "%s()\n", __func__);
	171
	172	/* Make sure RISC/FIFO are off before changing FIFO/RISC settings */
	173	cx_clear(AUD_INT_DMA_CTL, 0x11);
	174
	175	/* setup fifo + format - out channel */
	176	cx23885_sram_channel_setup(chip->dev, audio_ch, buf->bpl,
	177	buf->risc.dma);
	178
	179	/* sets bpl size */
	180	cx_write(AUD_INT_A_LNGTH, buf->bpl);
	181
	182	/* This is required to get good audio (1 seems to be ok) */
	183	cx_write(AUD_INT_A_MODE, 1);
	184
	185	/* reset counter */
	186	cx_write(AUD_INT_A_GPCNT_CTL, GP_COUNT_CONTROL_RESET);
	187	atomic_set(&chip->count, 0);
	188
	189	dprintk(1, "Start audio DMA, %d B/line, %d lines/FIFO, %d periods, %d "
	190	"byte buffer\n", buf->bpl, cx_read(audio_ch->cmds_start+12)>>1,
	191	chip->num_periods, buf->bpl * chip->num_periods);
	192
	193	/* Enables corresponding bits at AUD_INT_STAT */
	194	cx_write(AUDIO_INT_INT_MSK, AUD_INT_OPC_ERR \| AUD_INT_DN_SYNC \|
	195	AUD_INT_DN_RISCI1);
	196
	197	/* Clean any pending interrupt bits already set */
	198	cx_write(AUDIO_INT_INT_STAT, ~0);
	199
	200	/* enable audio irqs */
	201	cx_set(PCI_INT_MSK, chip->dev->pci_irqmask \| PCI_MSK_AUD_INT);
	202
	203	/* start dma */
	204	cx_set(DEV_CNTRL2, (1<<5)); /* Enables Risc Processor */
	205	cx_set(AUD_INT_DMA_CTL, 0x11); /* audio downstream FIFO and
	206	RISC enable */
	207	if (audio_debug)
	208	cx23885_sram_channel_dump(chip->dev, audio_ch);
	209
	210	return 0;
	211	}
	212
	213	/*
	214	* BOARD Specific: Resets audio DMA
	215	*/
	216	static int cx23885_stop_audio_dma(struct cx23885_audio_dev *chip)
	217	{
	218	struct cx23885_dev *dev = chip->dev;
	219	dprintk(1, "Stopping audio DMA\n");
	220
	221	/* stop dma */
	222	cx_clear(AUD_INT_DMA_CTL, 0x11);
223
224	/* disable irqs */
225	cx_clear(PCI_INT_MSK, PCI_MSK_AUD_INT);
226	cx_clear(AUDIO_INT_INT_MSK, AUD_INT_OPC_ERR \| AUD_INT_DN_SYNC \|
227	AUD_INT_DN_RISCI1);
228
229	if (audio_debug)
230	cx23885_sram_channel_dump(chip->dev,
231	&dev->sram_channels[AUDIO_SRAM_CHANNEL]);
232
233	return 0;
234	}
235
236	/*
237	* BOARD Specific: Handles audio IRQ
238	*/
239	int cx23885_audio_irq(struct cx23885_dev *dev, u32 status, u32 mask)
240	{
241	struct cx23885_audio_dev *chip = dev->audio_dev;
242
243	if (0 == (status & mask))
244	return 0;
245
246	cx_write(AUDIO_INT_INT_STAT, status);
247
248	/* risc op code error */
249	if (status & AUD_INT_OPC_ERR) {
250	printk(KERN_WARNING "%s/1: Audio risc op code error\n",
251	dev->name);
252	cx_clear(AUD_INT_DMA_CTL, 0x11);
253	cx23885_sram_channel_dump(dev,
254	&dev->sram_channels[AUDIO_SRAM_CHANNEL]);
255	}
256	if (status & AUD_INT_DN_SYNC) {
257	dprintk(1, "Downstream sync error\n");
258	cx_write(AUD_INT_A_GPCNT_CTL, GP_COUNT_CONTROL_RESET);
259	return 1;
260	}
261	/* risc1 downstream */
262	if (status & AUD_INT_DN_RISCI1) {
263	atomic_set(&chip->count, cx_read(AUD_INT_A_GPCNT));
264	snd_pcm_period_elapsed(chip->substream);
265	}
266	/* FIXME: Any other status should deserve a special handling? */
267
268	return 1;
269	}
270
271	static int dsp_buffer_free(struct cx23885_audio_dev *chip)
272	{
4d63a25c HV	273	struct cx23885_riscmem *risc;
4d63a25c HV	274
9e44d632 MM	275	BUG_ON(!chip->dma_size);
	276
	277	dprintk(2, "Freeing buffer\n");
9529a4b0 HV	278	cx23885_alsa_dma_unmap(chip);
9529a4b0 HV	279	cx23885_alsa_dma_free(chip->buf);
4d63a25c HV	280	risc = &chip->buf->risc;
4d63a25c HV	281	pci_free_consistent(chip->pci, risc->size, risc->cpu, risc->dma);
9e44d632 MM	282	kfree(chip->buf);
9e44d632 MM	283
9529a4b0	284	chip->buf = NULL;
9e44d632 MM	285	chip->dma_size = 0;
	286
	287	return 0;
	288	}
	289
	290	/****************************************************************************
	291	ALSA PCM Interface
	292	****************************************************************************/
	293
	294	/*
	295	* Digital hardware definition
	296	*/
	297	#define DEFAULT_FIFO_SIZE 4096
	298
	299	static struct snd_pcm_hardware snd_cx23885_digital_hw = {
	300	.info = SNDRV_PCM_INFO_MMAP \|
	301	SNDRV_PCM_INFO_INTERLEAVED \|
	302	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	303	SNDRV_PCM_INFO_MMAP_VALID,
	304	.formats = SNDRV_PCM_FMTBIT_S16_LE,
	305
	306	.rates = SNDRV_PCM_RATE_48000,
	307	.rate_min = 48000,
	308	.rate_max = 48000,
	309	.channels_min = 2,
	310	.channels_max = 2,
	311	/* Analog audio output will be full of clicks and pops if there
	312	are not exactly four lines in the SRAM FIFO buffer. */
	313	.period_bytes_min = DEFAULT_FIFO_SIZE/4,
	314	.period_bytes_max = DEFAULT_FIFO_SIZE/4,
	315	.periods_min = 1,
	316	.periods_max = 1024,
	317	.buffer_bytes_max = (1024*1024),
	318	};
	319
	320	/*
	321	* audio pcm capture open callback
	322	*/
	323	static int snd_cx23885_pcm_open(struct snd_pcm_substream *substream)
	324	{
	325	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	326	struct snd_pcm_runtime *runtime = substream->runtime;
	327	int err;
	328
	329	if (!chip) {
	330	printk(KERN_ERR "BUG: cx23885 can't find device struct."
	331	" Can't proceed with open\n");
	332	return -ENODEV;
	333	}
	334
	335	err = snd_pcm_hw_constraint_pow2(runtime, 0,
	336	SNDRV_PCM_HW_PARAM_PERIODS);
	337	if (err < 0)
	338	goto _error;
	339
	340	chip->substream = substream;
	341
	342	runtime->hw = snd_cx23885_digital_hw;
	343
	344	if (chip->dev->sram_channels[AUDIO_SRAM_CHANNEL].fifo_size !=
	345	DEFAULT_FIFO_SIZE) {
	346	unsigned int bpl = chip->dev->
	347	sram_channels[AUDIO_SRAM_CHANNEL].fifo_size / 4;
	348	bpl &= ~7; /* must be multiple of 8 */
349	runtime->hw.period_bytes_min = bpl;
350	runtime->hw.period_bytes_max = bpl;
351	}
352
353	return 0;
354	_error:
355	dprintk(1, "Error opening PCM!\n");
356	return err;
357	}
358
359	/*
360	* audio close callback
361	*/
362	static int snd_cx23885_close(struct snd_pcm_substream *substream)
363	{
364	return 0;
365	}
366
9529a4b0	367
9e44d632 MM	368	/*
	369	* hw_params callback
	370	*/
	371	static int snd_cx23885_hw_params(struct snd_pcm_substream *substream,
	372	struct snd_pcm_hw_params *hw_params)
	373	{
	374	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
9e44d632 MM	375	struct cx23885_audio_buffer *buf;
	376	int ret;
	377
	378	if (substream->runtime->dma_area) {
	379	dsp_buffer_free(chip);
	380	substream->runtime->dma_area = NULL;
	381	}
	382
	383	chip->period_size = params_period_bytes(hw_params);
	384	chip->num_periods = params_periods(hw_params);
	385	chip->dma_size = chip->period_size * params_periods(hw_params);
	386
	387	BUG_ON(!chip->dma_size);
	388	BUG_ON(chip->num_periods & (chip->num_periods-1));
	389
	390	buf = kzalloc(sizeof(*buf), GFP_KERNEL);
	391	if (NULL == buf)
	392	return -ENOMEM;
	393
	394	buf->bpl = chip->period_size;
453afdd9	395	chip->buf = buf;
9e44d632	396
9529a4b0	397	ret = cx23885_alsa_dma_init(chip,
9e44d632 MM	398	(PAGE_ALIGN(chip->dma_size) >> PAGE_SHIFT));
	399	if (ret < 0)
	400	goto error;
	401
9529a4b0	402	ret = cx23885_alsa_dma_map(chip);
9e44d632 MM	403	if (ret < 0)
	404	goto error;
	405
9529a4b0	406	ret = cx23885_risc_databuffer(chip->pci, &buf->risc, buf->sglist,
9e44d632 MM	407	chip->period_size, chip->num_periods, 1);
	408	if (ret < 0)
	409	goto error;
	410
	411	/* Loop back to start of program */
	412	buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP\|RISC_IRQ1\|RISC_CNT_INC);
	413	buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma);
	414	buf->risc.jmp[2] = cpu_to_le32(0); /* bits 63-32 */
	415
9529a4b0	416	substream->runtime->dma_area = chip->buf->vaddr;
9e44d632 MM	417	substream->runtime->dma_bytes = chip->dma_size;
	418	substream->runtime->dma_addr = 0;
	419
	420	return 0;
	421
	422	error:
	423	kfree(buf);
453afdd9	424	chip->buf = NULL;
9e44d632 MM	425	return ret;
	426	}
	427
	428	/*
	429	* hw free callback
	430	*/
	431	static int snd_cx23885_hw_free(struct snd_pcm_substream *substream)
	432	{
	433
	434	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	435
	436	if (substream->runtime->dma_area) {
	437	dsp_buffer_free(chip);
	438	substream->runtime->dma_area = NULL;
	439	}
	440
	441	return 0;
	442	}
	443
	444	/*
	445	* prepare callback
	446	*/
	447	static int snd_cx23885_prepare(struct snd_pcm_substream *substream)
	448	{
	449	return 0;
	450	}
	451
	452	/*
	453	* trigger callback
	454	*/
	455	static int snd_cx23885_card_trigger(struct snd_pcm_substream *substream,
	456	int cmd)
	457	{
	458	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	459	int err;
	460
	461	/* Local interrupts are already disabled by ALSA */
	462	spin_lock(&chip->lock);
	463
	464	switch (cmd) {
	465	case SNDRV_PCM_TRIGGER_START:
	466	err = cx23885_start_audio_dma(chip);
	467	break;
	468	case SNDRV_PCM_TRIGGER_STOP:
	469	err = cx23885_stop_audio_dma(chip);
	470	break;
	471	default:
	472	err = -EINVAL;
	473	break;
	474	}
	475
	476	spin_unlock(&chip->lock);
	477
	478	return err;
	479	}
	480
	481	/*
	482	* pointer callback
	483	*/
	484	static snd_pcm_uframes_t snd_cx23885_pointer(
	485	struct snd_pcm_substream *substream)
	486	{
	487	struct cx23885_audio_dev *chip = snd_pcm_substream_chip(substream);
	488	struct snd_pcm_runtime *runtime = substream->runtime;
489	u16 count;
490
491	count = atomic_read(&chip->count);
492
493	return runtime->period_size * (count & (runtime->periods-1));
494	}
495
496	/*
497	* page callback (needed for mmap)
498	*/
499	static struct page snd_cx23885_page(struct snd_pcm_substream substream,
500	unsigned long offset)
501	{
502	void *pageptr = substream->runtime->dma_area + offset;
503	return vmalloc_to_page(pageptr);
504	}
505
506	/*
507	* operators
508	*/
509	static struct snd_pcm_ops snd_cx23885_pcm_ops = {
510	.open = snd_cx23885_pcm_open,
511	.close = snd_cx23885_close,
512	.ioctl = snd_pcm_lib_ioctl,
513	.hw_params = snd_cx23885_hw_params,
514	.hw_free = snd_cx23885_hw_free,
515	.prepare = snd_cx23885_prepare,
516	.trigger = snd_cx23885_card_trigger,
517	.pointer = snd_cx23885_pointer,
518	.page = snd_cx23885_page,
519	};
520
521	/*
522	* create a PCM device
523	*/
524	static int snd_cx23885_pcm(struct cx23885_audio_dev *chip, int device,
525	char *name)
526	{
527	int err;
528	struct snd_pcm *pcm;
529
530	err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm);
531	if (err < 0)
532	return err;
533	pcm->private_data = chip;
534	strcpy(pcm->name, name);
535	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cx23885_pcm_ops);
536
537	return 0;
538	}
539
540	/****************************************************************************
541	Basic Flow for Sound Devices
542	****************************************************************************/
543
544	/*
545	* Alsa Constructor - Component probe
546	*/
547
efa762f5	548	struct cx23885_audio_dev cx23885_audio_register(struct cx23885_dev dev)
9e44d632 MM	549	{
	550	struct snd_card *card;
	551	struct cx23885_audio_dev *chip;
	552	int err;
	553
	554	if (disable_analog_audio)
	555	return NULL;
	556
	557	if (dev->sram_channels[AUDIO_SRAM_CHANNEL].cmds_start == 0) {
	558	printk(KERN_WARNING "%s(): Missing SRAM channel configuration "
	559	"for analog TV Audio\n", __func__);
	560	return NULL;
	561	}
	562
e7356888 TI	563	err = snd_card_new(&dev->pci->dev,
e7356888 TI	564	SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
9e44d632 MM	565	THIS_MODULE, sizeof(struct cx23885_audio_dev), &card);
	566	if (err < 0)
	567	goto error;
	568
	569	chip = (struct cx23885_audio_dev *) card->private_data;
	570	chip->dev = dev;
	571	chip->pci = dev->pci;
	572	chip->card = card;
	573	spin_lock_init(&chip->lock);
	574
9e44d632 MM	575	err = snd_cx23885_pcm(chip, 0, "CX23885 Digital");
	576	if (err < 0)
	577	goto error;
	578
	579	strcpy(card->driver, "CX23885");
	580	sprintf(card->shortname, "Conexant CX23885");
	581	sprintf(card->longname, "%s at %s", card->shortname, dev->name);
	582
	583	err = snd_card_register(card);
	584	if (err < 0)
	585	goto error;
	586
	587	dprintk(0, "registered ALSA audio device\n");
	588
	589	return chip;
	590
	591	error:
	592	snd_card_free(card);
	593	printk(KERN_ERR "%s(): Failed to register analog "
	594	"audio adapter\n", __func__);
	595
	596	return NULL;
	597	}
	598
	599	/*
	600	* ALSA destructor
	601	*/
efa762f5	602	void cx23885_audio_unregister(struct cx23885_dev *dev)
9e44d632 MM	603	{
	604	struct cx23885_audio_dev *chip = dev->audio_dev;
	605
	606	snd_card_free(chip->card);
	607	}