[deliverable/linux.git] / sound / pci / ctxfi / ctpcm.c

/**
 * Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
 *
 * This source file is released under GPL v2 license (no other versions).
 * See the COPYING file included in the main directory of this source
 * distribution for the license terms and conditions.
 *
 * @File	ctpcm.c
 *
 * @Brief
 * This file contains the definition of the pcm device functions.
 *
 * @Author	Liu Chun
 * @Date 	Apr 2 2008
 *
 */

#include "ctpcm.h"
#include "cttimer.h"
#include <sound/pcm.h>

/* Hardware descriptions for playback */
static struct snd_pcm_hardware ct_pcm_playback_hw = {
	.info			= (SNDRV_PCM_INFO_MMAP |
				   SNDRV_PCM_INFO_INTERLEAVED |
				   SNDRV_PCM_INFO_BLOCK_TRANSFER |
				   SNDRV_PCM_INFO_MMAP_VALID |
				   SNDRV_PCM_INFO_PAUSE),
	.formats		= (SNDRV_PCM_FMTBIT_U8 |
				   SNDRV_PCM_FMTBIT_S16_LE |
				   SNDRV_PCM_FMTBIT_S24_3LE |
				   SNDRV_PCM_FMTBIT_S32_LE |
				   SNDRV_PCM_FMTBIT_FLOAT_LE),
	.rates			= (SNDRV_PCM_RATE_CONTINUOUS |
				   SNDRV_PCM_RATE_8000_192000),
	.rate_min		= 8000,
	.rate_max		= 192000,
	.channels_min		= 1,
	.channels_max		= 2,
	.buffer_bytes_max	= (128*1024),
	.period_bytes_min	= (64),
	.period_bytes_max	= (128*1024),
	.periods_min		= 2,
	.periods_max		= 1024,
	.fifo_size		= 0,
};

static struct snd_pcm_hardware ct_spdif_passthru_playback_hw = {
	.info			= (SNDRV_PCM_INFO_MMAP |
				   SNDRV_PCM_INFO_INTERLEAVED |
				   SNDRV_PCM_INFO_BLOCK_TRANSFER |
				   SNDRV_PCM_INFO_MMAP_VALID |
				   SNDRV_PCM_INFO_PAUSE),
	.formats		= SNDRV_PCM_FMTBIT_S16_LE,
	.rates			= (SNDRV_PCM_RATE_48000 |
				   SNDRV_PCM_RATE_44100 |
				   SNDRV_PCM_RATE_32000),
	.rate_min		= 32000,
	.rate_max		= 48000,
	.channels_min		= 2,
	.channels_max		= 2,
	.buffer_bytes_max	= (128*1024),
	.period_bytes_min	= (64),
	.period_bytes_max	= (128*1024),
	.periods_min		= 2,
	.periods_max		= 1024,
	.fifo_size		= 0,
};

/* Hardware descriptions for capture */
static struct snd_pcm_hardware ct_pcm_capture_hw = {
	.info			= (SNDRV_PCM_INFO_MMAP |
				   SNDRV_PCM_INFO_INTERLEAVED |
				   SNDRV_PCM_INFO_BLOCK_TRANSFER |
				   SNDRV_PCM_INFO_PAUSE |
				   SNDRV_PCM_INFO_MMAP_VALID),
	.formats		= (SNDRV_PCM_FMTBIT_U8 |
				   SNDRV_PCM_FMTBIT_S16_LE |
				   SNDRV_PCM_FMTBIT_S24_3LE |
				   SNDRV_PCM_FMTBIT_S32_LE |
				   SNDRV_PCM_FMTBIT_FLOAT_LE),
	.rates			= (SNDRV_PCM_RATE_CONTINUOUS |
				   SNDRV_PCM_RATE_8000_96000),
	.rate_min		= 8000,
	.rate_max		= 96000,
	.channels_min		= 1,
	.channels_max		= 2,
	.buffer_bytes_max	= (128*1024),
	.period_bytes_min	= (384),
	.period_bytes_max	= (64*1024),
	.periods_min		= 2,
	.periods_max		= 1024,
	.fifo_size		= 0,
};

static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
{
	struct ct_atc_pcm *apcm = atc_pcm;

	if (NULL == apcm->substream)
		return;

	snd_pcm_period_elapsed(apcm->substream);
}

static void ct_atc_pcm_free_substream(struct snd_pcm_runtime *runtime)
{
	struct ct_atc_pcm *apcm = runtime->private_data;
	struct ct_atc *atc = snd_pcm_substream_chip(apcm->substream);

	atc->pcm_release_resources(atc, apcm);
	ct_timer_instance_free(apcm->timer);
	kfree(apcm);
	runtime->private_data = NULL;
}

/* pcm playback operations */
static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
{
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm;
	int err;

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

	apcm->substream = substream;
	apcm->interrupt = ct_atc_pcm_interrupt;
	runtime->private_data = apcm;
	runtime->private_free = ct_atc_pcm_free_substream;
	if (IEC958 == substream->pcm->device) {
		runtime->hw = ct_spdif_passthru_playback_hw;
		atc->spdif_out_passthru(atc, 1);
	} else {
		runtime->hw = ct_pcm_playback_hw;
		if (FRONT == substream->pcm->device)
			runtime->hw.channels_max = 8;
	}

	err = snd_pcm_hw_constraint_integer(runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (err < 0) {
		kfree(apcm);
		return err;
	}
	err = snd_pcm_hw_constraint_minmax(runtime,
					   SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
					   1024, UINT_MAX);
	if (err < 0) {
		kfree(apcm);
		return err;
	}

	apcm->timer = ct_timer_instance_new(atc->timer, apcm);
	if (!apcm->timer)
		return -ENOMEM;

	return 0;
}

static int ct_pcm_playback_close(struct snd_pcm_substream *substream)
{
	struct ct_atc *atc = snd_pcm_substream_chip(substream);

	/* TODO: Notify mixer inactive. */
	if (IEC958 == substream->pcm->device)
		atc->spdif_out_passthru(atc, 0);

	/* The ct_atc_pcm object will be freed by runtime->private_free */

	return 0;
}

static int ct_pcm_hw_params(struct snd_pcm_substream *substream,
				     struct snd_pcm_hw_params *hw_params)
{
	return snd_pcm_lib_malloc_pages(substream,
					params_buffer_bytes(hw_params));
}

static int ct_pcm_hw_free(struct snd_pcm_substream *substream)
{
	/* Free snd-allocated pages */
	return snd_pcm_lib_free_pages(substream);
}


static int ct_pcm_playback_prepare(struct snd_pcm_substream *substream)
{
	int err;
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm = runtime->private_data;

	if (IEC958 == substream->pcm->device)
		err = atc->spdif_passthru_playback_prepare(atc, apcm);
	else
		err = atc->pcm_playback_prepare(atc, apcm);

	if (err < 0) {
		printk(KERN_ERR "ctxfi: Preparing pcm playback failed!!!\n");
		return err;
	}

	return 0;
}

static int
ct_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm = runtime->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		atc->pcm_playback_start(atc, apcm);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		atc->pcm_playback_stop(atc, apcm);
		break;
	default:
		break;
	}

	return 0;
}

static snd_pcm_uframes_t
ct_pcm_playback_pointer(struct snd_pcm_substream *substream)
{
	unsigned long position;
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm = runtime->private_data;

	/* Read out playback position */
	position = atc->pcm_playback_position(atc, apcm);
	position = bytes_to_frames(runtime, position);
	return position;
}

/* pcm capture operations */
static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
{
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm;
	int err;

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

	apcm->started = 0;
	apcm->substream = substream;
	apcm->interrupt = ct_atc_pcm_interrupt;
	runtime->private_data = apcm;
	runtime->private_free = ct_atc_pcm_free_substream;
	runtime->hw = ct_pcm_capture_hw;
	runtime->hw.rate_max = atc->rsr * atc->msr;

	err = snd_pcm_hw_constraint_integer(runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (err < 0) {
		kfree(apcm);
		return err;
	}
	err = snd_pcm_hw_constraint_minmax(runtime,
					   SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
					   1024, UINT_MAX);
	if (err < 0) {
		kfree(apcm);
		return err;
	}

	apcm->timer = ct_timer_instance_new(atc->timer, apcm);
	if (!apcm->timer)
		return -ENOMEM;

	return 0;
}

static int ct_pcm_capture_close(struct snd_pcm_substream *substream)
{
	/* The ct_atc_pcm object will be freed by runtime->private_free */
	/* TODO: Notify mixer inactive. */
	return 0;
}

static int ct_pcm_capture_prepare(struct snd_pcm_substream *substream)
{
	int err;
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm = runtime->private_data;

	err = atc->pcm_capture_prepare(atc, apcm);
	if (err < 0) {
		printk(KERN_ERR "ctxfi: Preparing pcm capture failed!!!\n");
		return err;
	}

	return 0;
}

static int
ct_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm = runtime->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		atc->pcm_capture_start(atc, apcm);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		atc->pcm_capture_stop(atc, apcm);
		break;
	default:
		atc->pcm_capture_stop(atc, apcm);
		break;
	}

	return 0;
}

static snd_pcm_uframes_t
ct_pcm_capture_pointer(struct snd_pcm_substream *substream)
{
	unsigned long position;
	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ct_atc_pcm *apcm = runtime->private_data;

	/* Read out playback position */
	position = atc->pcm_capture_position(atc, apcm);
	position = bytes_to_frames(runtime, position);
	return position;
}

/* PCM operators for playback */
static struct snd_pcm_ops ct_pcm_playback_ops = {
	.open	 	= ct_pcm_playback_open,
	.close		= ct_pcm_playback_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= ct_pcm_hw_params,
	.hw_free	= ct_pcm_hw_free,
	.prepare	= ct_pcm_playback_prepare,
	.trigger	= ct_pcm_playback_trigger,
	.pointer	= ct_pcm_playback_pointer,
	.page		= snd_pcm_sgbuf_ops_page,
};

/* PCM operators for capture */
static struct snd_pcm_ops ct_pcm_capture_ops = {
	.open	 	= ct_pcm_capture_open,
	.close		= ct_pcm_capture_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= ct_pcm_hw_params,
	.hw_free	= ct_pcm_hw_free,
	.prepare	= ct_pcm_capture_prepare,
	.trigger	= ct_pcm_capture_trigger,
	.pointer	= ct_pcm_capture_pointer,
	.page		= snd_pcm_sgbuf_ops_page,
};

/* Create ALSA pcm device */
int ct_alsa_pcm_create(struct ct_atc *atc,
		       enum CTALSADEVS device,
		       const char *device_name)
{
	struct snd_pcm *pcm;
	int err;
	int playback_count, capture_count;

	playback_count = (IEC958 == device) ? 1 : 8;
	capture_count = (FRONT == device) ? 1 : 0;
	err = snd_pcm_new(atc->card, "ctxfi", device,
			  playback_count, capture_count, &pcm);
	if (err < 0) {
		printk(KERN_ERR "ctxfi: snd_pcm_new failed!! Err=%d\n", err);
		return err;
	}

	pcm->private_data = atc;
	pcm->info_flags = 0;
	pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
	strlcpy(pcm->name, device_name, sizeof(pcm->name));

	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops);

	if (FRONT == device)
		snd_pcm_set_ops(pcm,
				SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);

	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
			snd_dma_pci_data(atc->pci), 128*1024, 128*1024);

	return 0;
}
Commit	Line	Data
8cc72361 WYC	1	/**
	2	* Copyright (C) 2008, Creative Technology Ltd. All Rights Reserved.
	3	*
	4	* This source file is released under GPL v2 license (no other versions).
	5	* See the COPYING file included in the main directory of this source
	6	* distribution for the license terms and conditions.
	7	*
	8	* @File ctpcm.c
	9	*
	10	* @Brief
	11	* This file contains the definition of the pcm device functions.
	12	*
	13	* @Author Liu Chun
	14	* @Date Apr 2 2008
	15	*
	16	*/
	17
	18	#include "ctpcm.h"
b7bbf876	19	#include "cttimer.h"
8cc72361 WYC	20	#include <sound/pcm.h>
	21
	22	/* Hardware descriptions for playback */
	23	static struct snd_pcm_hardware ct_pcm_playback_hw = {
	24	.info = (SNDRV_PCM_INFO_MMAP \|
	25	SNDRV_PCM_INFO_INTERLEAVED \|
	26	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	27	SNDRV_PCM_INFO_MMAP_VALID \|
	28	SNDRV_PCM_INFO_PAUSE),
	29	.formats = (SNDRV_PCM_FMTBIT_U8 \|
8cc72361	30	SNDRV_PCM_FMTBIT_S16_LE \|
8cc72361	31	SNDRV_PCM_FMTBIT_S24_3LE \|
d2b9b96c TI	32	SNDRV_PCM_FMTBIT_S32_LE \|
d2b9b96c TI	33	SNDRV_PCM_FMTBIT_FLOAT_LE),
8cc72361 WYC	34	.rates = (SNDRV_PCM_RATE_CONTINUOUS \|
	35	SNDRV_PCM_RATE_8000_192000),
	36	.rate_min = 8000,
	37	.rate_max = 192000,
	38	.channels_min = 1,
	39	.channels_max = 2,
	40	.buffer_bytes_max = (128*1024),
	41	.period_bytes_min = (64),
	42	.period_bytes_max = (128*1024),
775ffa1d	43	.periods_min = 2,
8cc72361 WYC	44	.periods_max = 1024,
	45	.fifo_size = 0,
	46	};
	47
	48	static struct snd_pcm_hardware ct_spdif_passthru_playback_hw = {
	49	.info = (SNDRV_PCM_INFO_MMAP \|
	50	SNDRV_PCM_INFO_INTERLEAVED \|
	51	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	52	SNDRV_PCM_INFO_MMAP_VALID \|
	53	SNDRV_PCM_INFO_PAUSE),
d2b9b96c	54	.formats = SNDRV_PCM_FMTBIT_S16_LE,
8cc72361 WYC	55	.rates = (SNDRV_PCM_RATE_48000 \|
	56	SNDRV_PCM_RATE_44100 \|
	57	SNDRV_PCM_RATE_32000),
	58	.rate_min = 32000,
	59	.rate_max = 48000,
	60	.channels_min = 2,
	61	.channels_max = 2,
	62	.buffer_bytes_max = (128*1024),
	63	.period_bytes_min = (64),
	64	.period_bytes_max = (128*1024),
775ffa1d	65	.periods_min = 2,
8cc72361 WYC	66	.periods_max = 1024,
	67	.fifo_size = 0,
	68	};
	69
	70	/* Hardware descriptions for capture */
	71	static struct snd_pcm_hardware ct_pcm_capture_hw = {
	72	.info = (SNDRV_PCM_INFO_MMAP \|
	73	SNDRV_PCM_INFO_INTERLEAVED \|
	74	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	75	SNDRV_PCM_INFO_PAUSE \|
	76	SNDRV_PCM_INFO_MMAP_VALID),
	77	.formats = (SNDRV_PCM_FMTBIT_U8 \|
8cc72361	78	SNDRV_PCM_FMTBIT_S16_LE \|
8cc72361	79	SNDRV_PCM_FMTBIT_S24_3LE \|
d2b9b96c TI	80	SNDRV_PCM_FMTBIT_S32_LE \|
d2b9b96c TI	81	SNDRV_PCM_FMTBIT_FLOAT_LE),
8cc72361 WYC	82	.rates = (SNDRV_PCM_RATE_CONTINUOUS \|
	83	SNDRV_PCM_RATE_8000_96000),
	84	.rate_min = 8000,
	85	.rate_max = 96000,
	86	.channels_min = 1,
	87	.channels_max = 2,
	88	.buffer_bytes_max = (128*1024),
	89	.period_bytes_min = (384),
	90	.period_bytes_max = (64*1024),
	91	.periods_min = 2,
	92	.periods_max = 1024,
	93	.fifo_size = 0,
	94	};
	95
	96	static void ct_atc_pcm_interrupt(struct ct_atc_pcm *atc_pcm)
	97	{
	98	struct ct_atc_pcm *apcm = atc_pcm;
	99
	100	if (NULL == apcm->substream)
	101	return;
	102
	103	snd_pcm_period_elapsed(apcm->substream);
	104	}
	105
	106	static void ct_atc_pcm_free_substream(struct snd_pcm_runtime *runtime)
	107	{
	108	struct ct_atc_pcm *apcm = runtime->private_data;
	109	struct ct_atc *atc = snd_pcm_substream_chip(apcm->substream);
	110
	111	atc->pcm_release_resources(atc, apcm);
b7bbf876	112	ct_timer_instance_free(apcm->timer);
8cc72361 WYC	113	kfree(apcm);
	114	runtime->private_data = NULL;
	115	}
	116
	117	/* pcm playback operations */
	118	static int ct_pcm_playback_open(struct snd_pcm_substream *substream)
	119	{
	120	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	121	struct snd_pcm_runtime *runtime = substream->runtime;
	122	struct ct_atc_pcm *apcm;
	123	int err;
	124
	125	apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
	126	if (NULL == apcm)
	127	return -ENOMEM;
	128
8cc72361 WYC	129	apcm->substream = substream;
	130	apcm->interrupt = ct_atc_pcm_interrupt;
	131	runtime->private_data = apcm;
	132	runtime->private_free = ct_atc_pcm_free_substream;
	133	if (IEC958 == substream->pcm->device) {
	134	runtime->hw = ct_spdif_passthru_playback_hw;
	135	atc->spdif_out_passthru(atc, 1);
	136	} else {
	137	runtime->hw = ct_pcm_playback_hw;
	138	if (FRONT == substream->pcm->device)
	139	runtime->hw.channels_max = 8;
	140	}
	141
	142	err = snd_pcm_hw_constraint_integer(runtime,
	143	SNDRV_PCM_HW_PARAM_PERIODS);
	144	if (err < 0) {
	145	kfree(apcm);
	146	return err;
	147	}
	148	err = snd_pcm_hw_constraint_minmax(runtime,
	149	SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
	150	1024, UINT_MAX);
	151	if (err < 0) {
	152	kfree(apcm);
	153	return err;
	154	}
	155
b7bbf876 TI	156	apcm->timer = ct_timer_instance_new(atc->timer, apcm);
	157	if (!apcm->timer)
	158	return -ENOMEM;
	159
8cc72361 WYC	160	return 0;
	161	}
	162
	163	static int ct_pcm_playback_close(struct snd_pcm_substream *substream)
	164	{
	165	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	166
	167	/* TODO: Notify mixer inactive. */
	168	if (IEC958 == substream->pcm->device)
	169	atc->spdif_out_passthru(atc, 0);
	170
	171	/* The ct_atc_pcm object will be freed by runtime->private_free */
	172
	173	return 0;
	174	}
	175
	176	static int ct_pcm_hw_params(struct snd_pcm_substream *substream,
	177	struct snd_pcm_hw_params *hw_params)
	178	{
	179	return snd_pcm_lib_malloc_pages(substream,
	180	params_buffer_bytes(hw_params));
	181	}
	182
	183	static int ct_pcm_hw_free(struct snd_pcm_substream *substream)
	184	{
	185	/* Free snd-allocated pages */
	186	return snd_pcm_lib_free_pages(substream);
	187	}
	188
8cc72361 WYC	189
	190	static int ct_pcm_playback_prepare(struct snd_pcm_substream *substream)
	191	{
	192	int err;
	193	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	194	struct snd_pcm_runtime *runtime = substream->runtime;
	195	struct ct_atc_pcm *apcm = runtime->private_data;
	196
	197	if (IEC958 == substream->pcm->device)
	198	err = atc->spdif_passthru_playback_prepare(atc, apcm);
	199	else
	200	err = atc->pcm_playback_prepare(atc, apcm);
	201
	202	if (err < 0) {
b3e0afe6	203	printk(KERN_ERR "ctxfi: Preparing pcm playback failed!!!\n");
8cc72361 WYC	204	return err;
	205	}
	206
8cc72361 WYC	207	return 0;
	208	}
	209
	210	static int
	211	ct_pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
	212	{
	213	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	214	struct snd_pcm_runtime *runtime = substream->runtime;
	215	struct ct_atc_pcm *apcm = runtime->private_data;
	216
	217	switch (cmd) {
	218	case SNDRV_PCM_TRIGGER_START:
	219	case SNDRV_PCM_TRIGGER_RESUME:
	220	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	221	atc->pcm_playback_start(atc, apcm);
8cc72361 WYC	222	break;
	223	case SNDRV_PCM_TRIGGER_STOP:
	224	case SNDRV_PCM_TRIGGER_SUSPEND:
	225	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
8cc72361 WYC	226	atc->pcm_playback_stop(atc, apcm);
	227	break;
	228	default:
	229	break;
	230	}
	231
	232	return 0;
	233	}
	234
	235	static snd_pcm_uframes_t
	236	ct_pcm_playback_pointer(struct snd_pcm_substream *substream)
	237	{
	238	unsigned long position;
	239	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	240	struct snd_pcm_runtime *runtime = substream->runtime;
	241	struct ct_atc_pcm *apcm = runtime->private_data;
	242
	243	/* Read out playback position */
	244	position = atc->pcm_playback_position(atc, apcm);
	245	position = bytes_to_frames(runtime, position);
	246	return position;
	247	}
	248
	249	/* pcm capture operations */
	250	static int ct_pcm_capture_open(struct snd_pcm_substream *substream)
	251	{
	252	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	253	struct snd_pcm_runtime *runtime = substream->runtime;
	254	struct ct_atc_pcm *apcm;
	255	int err;
	256
	257	apcm = kzalloc(sizeof(*apcm), GFP_KERNEL);
	258	if (NULL == apcm)
	259	return -ENOMEM;
	260
8cc72361	261	apcm->started = 0;
8cc72361 WYC	262	apcm->substream = substream;
	263	apcm->interrupt = ct_atc_pcm_interrupt;
	264	runtime->private_data = apcm;
	265	runtime->private_free = ct_atc_pcm_free_substream;
	266	runtime->hw = ct_pcm_capture_hw;
	267	runtime->hw.rate_max = atc->rsr * atc->msr;
	268
	269	err = snd_pcm_hw_constraint_integer(runtime,
	270	SNDRV_PCM_HW_PARAM_PERIODS);
	271	if (err < 0) {
	272	kfree(apcm);
	273	return err;
	274	}
	275	err = snd_pcm_hw_constraint_minmax(runtime,
	276	SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
	277	1024, UINT_MAX);
	278	if (err < 0) {
	279	kfree(apcm);
	280	return err;
	281	}
	282
b7bbf876 TI	283	apcm->timer = ct_timer_instance_new(atc->timer, apcm);
	284	if (!apcm->timer)
	285	return -ENOMEM;
	286
8cc72361 WYC	287	return 0;
	288	}
	289
	290	static int ct_pcm_capture_close(struct snd_pcm_substream *substream)
	291	{
	292	/* The ct_atc_pcm object will be freed by runtime->private_free */
	293	/* TODO: Notify mixer inactive. */
	294	return 0;
	295	}
	296
	297	static int ct_pcm_capture_prepare(struct snd_pcm_substream *substream)
	298	{
	299	int err;
	300	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	301	struct snd_pcm_runtime *runtime = substream->runtime;
	302	struct ct_atc_pcm *apcm = runtime->private_data;
	303
	304	err = atc->pcm_capture_prepare(atc, apcm);
	305	if (err < 0) {
b3e0afe6	306	printk(KERN_ERR "ctxfi: Preparing pcm capture failed!!!\n");
8cc72361 WYC	307	return err;
	308	}
	309
8cc72361 WYC	310	return 0;
	311	}
	312
	313	static int
	314	ct_pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
	315	{
	316	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	317	struct snd_pcm_runtime *runtime = substream->runtime;
	318	struct ct_atc_pcm *apcm = runtime->private_data;
	319
	320	switch (cmd) {
	321	case SNDRV_PCM_TRIGGER_START:
	322	atc->pcm_capture_start(atc, apcm);
8cc72361 WYC	323	break;
8cc72361 WYC	324	case SNDRV_PCM_TRIGGER_STOP:
8cc72361 WYC	325	atc->pcm_capture_stop(atc, apcm);
	326	break;
	327	default:
8cc72361 WYC	328	atc->pcm_capture_stop(atc, apcm);
	329	break;
	330	}
	331
	332	return 0;
	333	}
	334
	335	static snd_pcm_uframes_t
	336	ct_pcm_capture_pointer(struct snd_pcm_substream *substream)
	337	{
	338	unsigned long position;
	339	struct ct_atc *atc = snd_pcm_substream_chip(substream);
	340	struct snd_pcm_runtime *runtime = substream->runtime;
	341	struct ct_atc_pcm *apcm = runtime->private_data;
	342
	343	/* Read out playback position */
	344	position = atc->pcm_capture_position(atc, apcm);
	345	position = bytes_to_frames(runtime, position);
	346	return position;
	347	}
	348
	349	/* PCM operators for playback */
	350	static struct snd_pcm_ops ct_pcm_playback_ops = {
	351	.open = ct_pcm_playback_open,
	352	.close = ct_pcm_playback_close,
	353	.ioctl = snd_pcm_lib_ioctl,
	354	.hw_params = ct_pcm_hw_params,
	355	.hw_free = ct_pcm_hw_free,
	356	.prepare = ct_pcm_playback_prepare,
	357	.trigger = ct_pcm_playback_trigger,
	358	.pointer = ct_pcm_playback_pointer,
c76157d9	359	.page = snd_pcm_sgbuf_ops_page,
8cc72361 WYC	360	};
	361
	362	/* PCM operators for capture */
	363	static struct snd_pcm_ops ct_pcm_capture_ops = {
	364	.open = ct_pcm_capture_open,
	365	.close = ct_pcm_capture_close,
	366	.ioctl = snd_pcm_lib_ioctl,
	367	.hw_params = ct_pcm_hw_params,
	368	.hw_free = ct_pcm_hw_free,
	369	.prepare = ct_pcm_capture_prepare,
	370	.trigger = ct_pcm_capture_trigger,
	371	.pointer = ct_pcm_capture_pointer,
c76157d9	372	.page = snd_pcm_sgbuf_ops_page,
8cc72361 WYC	373	};
	374
	375	/* Create ALSA pcm device */
	376	int ct_alsa_pcm_create(struct ct_atc *atc,
	377	enum CTALSADEVS device,
	378	const char *device_name)
	379	{
	380	struct snd_pcm *pcm;
	381	int err;
	382	int playback_count, capture_count;
8cc72361	383
8cc72361 WYC	384	playback_count = (IEC958 == device) ? 1 : 8;
8cc72361 WYC	385	capture_count = (FRONT == device) ? 1 : 0;
8372d498	386	err = snd_pcm_new(atc->card, "ctxfi", device,
8cc72361 WYC	387	playback_count, capture_count, &pcm);
8cc72361 WYC	388	if (err < 0) {
b3e0afe6	389	printk(KERN_ERR "ctxfi: snd_pcm_new failed!! Err=%d\n", err);
8cc72361 WYC	390	return err;
	391	}
	392
	393	pcm->private_data = atc;
	394	pcm->info_flags = 0;
	395	pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
8372d498	396	strlcpy(pcm->name, device_name, sizeof(pcm->name));
8cc72361 WYC	397
	398	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ct_pcm_playback_ops);
	399
	400	if (FRONT == device)
	401	snd_pcm_set_ops(pcm,
	402	SNDRV_PCM_STREAM_CAPTURE, &ct_pcm_capture_ops);
	403
c76157d9	404	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
8cc72361 WYC	405	snd_dma_pci_data(atc->pci), 1281024, 1281024);
	406
	407	return 0;
	408	}