[thirdparty/kernel/stable.git] / drivers / media / pci / cx23885 / cx23885-alsa.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *
 *  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>
 */

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

#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>

#define AUDIO_SRAM_CHANNEL	SRAM_CH07

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

/****************************************************************************
			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 functions
 ****************************************************************************/

/* 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 %p, size=%d\n",
		buf->vaddr, nr_pages << PAGE_SHIFT);

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

	buf->sglist = vzalloc(array_size(sizeof(*buf->sglist), buf->nr_pages));
	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) {
		pr_warn("%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 const 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) {
		pr_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 const 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;
	strscpy(pcm->name, name, sizeof(pcm->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) {
		pr_warn("%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;

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