[deliverable/linux.git] / sound / firewire / oxfw / oxfw-pcm.c

/*
 * oxfw_pcm.c - a part of driver for OXFW970/971 based devices
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include "oxfw.h"

static int hw_rule_rate(struct snd_pcm_hw_params *params,
			struct snd_pcm_hw_rule *rule)
{
	u8 **formats = rule->private;
	struct snd_interval *r =
		hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
	const struct snd_interval *c =
		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	struct snd_interval t = {
		.min = UINT_MAX, .max = 0, .integer = 1
	};
	struct snd_oxfw_stream_formation formation;
	unsigned int i, err;

	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
		if (formats[i] == NULL)
			continue;

		err = snd_oxfw_stream_parse_format(formats[i], &formation);
		if (err < 0)
			continue;
		if (!snd_interval_test(c, formation.pcm))
			continue;

		t.min = min(t.min, formation.rate);
		t.max = max(t.max, formation.rate);

	}
	return snd_interval_refine(r, &t);
}

static int hw_rule_channels(struct snd_pcm_hw_params *params,
			    struct snd_pcm_hw_rule *rule)
{
	u8 **formats = rule->private;
	struct snd_interval *c =
		hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	const struct snd_interval *r =
		hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
	struct snd_oxfw_stream_formation formation;
	unsigned int i, j, err;
	unsigned int count, list[SND_OXFW_STREAM_FORMAT_ENTRIES] = {0};

	count = 0;
	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
		if (formats[i] == NULL)
			break;

		err = snd_oxfw_stream_parse_format(formats[i], &formation);
		if (err < 0)
			continue;
		if (!snd_interval_test(r, formation.rate))
			continue;
		if (list[count] == formation.pcm)
			continue;

		for (j = 0; j < ARRAY_SIZE(list); j++) {
			if (list[j] == formation.pcm)
				break;
		}
		if (j == ARRAY_SIZE(list)) {
			list[count] = formation.pcm;
			if (++count == ARRAY_SIZE(list))
				break;
		}
	}

	return snd_interval_list(c, count, list, 0);
}

static void limit_channels_and_rates(struct snd_pcm_hardware *hw, u8 **formats)
{
	struct snd_oxfw_stream_formation formation;
	unsigned int i, err;

	hw->channels_min = UINT_MAX;
	hw->channels_max = 0;

	hw->rate_min = UINT_MAX;
	hw->rate_max = 0;
	hw->rates = 0;

	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
		if (formats[i] == NULL)
			break;

		err = snd_oxfw_stream_parse_format(formats[i], &formation);
		if (err < 0)
			continue;

		hw->channels_min = min(hw->channels_min, formation.pcm);
		hw->channels_max = max(hw->channels_max, formation.pcm);

		hw->rate_min = min(hw->rate_min, formation.rate);
		hw->rate_max = max(hw->rate_max, formation.rate);
		hw->rates |= snd_pcm_rate_to_rate_bit(formation.rate);
	}
}

static void limit_period_and_buffer(struct snd_pcm_hardware *hw)
{
	hw->periods_min = 2;		/* SNDRV_PCM_INFO_BATCH */
	hw->periods_max = UINT_MAX;

	hw->period_bytes_min = 4 * hw->channels_max;	/* bytes for a frame */

	/* Just to prevent from allocating much pages. */
	hw->period_bytes_max = hw->period_bytes_min * 2048;
	hw->buffer_bytes_max = hw->period_bytes_max * hw->periods_min;
}

static int pcm_open(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
	u8 **formats;
	int err;

	formats = oxfw->rx_stream_formats;

	runtime->hw.info = SNDRV_PCM_INFO_BATCH |
			   SNDRV_PCM_INFO_BLOCK_TRANSFER |
			   SNDRV_PCM_INFO_INTERLEAVED |
			   SNDRV_PCM_INFO_MMAP |
			   SNDRV_PCM_INFO_MMAP_VALID;

	limit_channels_and_rates(&runtime->hw, formats);
	limit_period_and_buffer(&runtime->hw);

	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
				  hw_rule_channels, formats,
				  SNDRV_PCM_HW_PARAM_RATE, -1);
	if (err < 0)
		goto end;

	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
				  hw_rule_rate, formats,
				  SNDRV_PCM_HW_PARAM_CHANNELS, -1);
	if (err < 0)
		goto end;

	err = amdtp_stream_add_pcm_hw_constraints(&oxfw->rx_stream, runtime);
	if (err < 0)
		goto end;

	snd_pcm_set_sync(substream);
end:
	return err;
}

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

static int pcm_hw_params(struct snd_pcm_substream *substream,
			 struct snd_pcm_hw_params *hw_params)
{
	struct snd_oxfw *oxfw = substream->private_data;
	int err;

	mutex_lock(&oxfw->mutex);

	snd_oxfw_stream_stop_simplex(oxfw);

	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
					       params_buffer_bytes(hw_params));
	if (err < 0)
		goto error;

	amdtp_stream_set_parameters(&oxfw->rx_stream,
				    params_rate(hw_params),
				    params_channels(hw_params),
				    0);

	amdtp_stream_set_pcm_format(&oxfw->rx_stream,
				    params_format(hw_params));

	err = avc_general_set_sig_fmt(oxfw->unit, params_rate(hw_params),
				      AVC_GENERAL_PLUG_DIR_IN, 0);
	if (err < 0) {
		dev_err(&oxfw->unit->device, "failed to set sample rate\n");
		goto err_buffer;
	}

	return 0;

err_buffer:
	snd_pcm_lib_free_vmalloc_buffer(substream);
error:
	mutex_unlock(&oxfw->mutex);
	return err;
}

static int pcm_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;

	mutex_lock(&oxfw->mutex);
	snd_oxfw_stream_stop_simplex(oxfw);
	mutex_unlock(&oxfw->mutex);

	return snd_pcm_lib_free_vmalloc_buffer(substream);
}

static int pcm_prepare(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;
	int err;

	mutex_lock(&oxfw->mutex);

	snd_oxfw_stream_stop_simplex(oxfw);

	err = snd_oxfw_stream_start_simplex(oxfw);
	if (err < 0)
		goto end;

	amdtp_stream_pcm_prepare(&oxfw->rx_stream);
end:
	mutex_unlock(&oxfw->mutex);
	return err;
}

static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	struct snd_oxfw *oxfw = substream->private_data;
	struct snd_pcm_substream *pcm;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		pcm = substream;
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		pcm = NULL;
		break;
	default:
		return -EINVAL;
	}
	amdtp_stream_pcm_trigger(&oxfw->rx_stream, pcm);
	return 0;
}

static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;

	return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
}

int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
{
	static struct snd_pcm_ops ops = {
		.open      = pcm_open,
		.close     = pcm_close,
		.ioctl     = snd_pcm_lib_ioctl,
		.hw_params = pcm_hw_params,
		.hw_free   = pcm_hw_free,
		.prepare   = pcm_prepare,
		.trigger   = pcm_trigger,
		.pointer   = pcm_pointer,
		.page      = snd_pcm_lib_get_vmalloc_page,
		.mmap      = snd_pcm_lib_mmap_vmalloc,
	};
	struct snd_pcm *pcm;
	int err;

	err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, 0, &pcm);
	if (err < 0)
		return err;
	pcm->private_data = oxfw;
	strcpy(pcm->name, oxfw->card->shortname);
	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops);
	return 0;
}
Commit	Line	Data
3713d93a TS	1	/*
	2	* oxfw_pcm.c - a part of driver for OXFW970/971 based devices
	3	*
	4	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
	5	* Licensed under the terms of the GNU General Public License, version 2.
	6	*/
	7
	8	#include "oxfw.h"
	9
5cd1d3f4 TS	10	static int hw_rule_rate(struct snd_pcm_hw_params *params,
5cd1d3f4 TS	11	struct snd_pcm_hw_rule *rule)
3713d93a	12	{
5cd1d3f4 TS	13	u8 **formats = rule->private;
	14	struct snd_interval *r =
	15	hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
	16	const struct snd_interval *c =
	17	hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	18	struct snd_interval t = {
	19	.min = UINT_MAX, .max = 0, .integer = 1
	20	};
	21	struct snd_oxfw_stream_formation formation;
	22	unsigned int i, err;
	23
	24	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
	25	if (formats[i] == NULL)
	26	continue;
	27
	28	err = snd_oxfw_stream_parse_format(formats[i], &formation);
	29	if (err < 0)
	30	continue;
	31	if (!snd_interval_test(c, formation.pcm))
	32	continue;
	33
	34	t.min = min(t.min, formation.rate);
	35	t.max = max(t.max, formation.rate);
	36
	37	}
	38	return snd_interval_refine(r, &t);
3713d93a TS	39	}
3713d93a TS	40
5cd1d3f4 TS	41	static int hw_rule_channels(struct snd_pcm_hw_params *params,
5cd1d3f4 TS	42	struct snd_pcm_hw_rule *rule)
3713d93a	43	{
5cd1d3f4 TS	44	u8 **formats = rule->private;
	45	struct snd_interval *c =
	46	hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	47	const struct snd_interval *r =
	48	hw_param_interval_c(params, SNDRV_PCM_HW_PARAM_RATE);
	49	struct snd_oxfw_stream_formation formation;
	50	unsigned int i, j, err;
	51	unsigned int count, list[SND_OXFW_STREAM_FORMAT_ENTRIES] = {0};
	52
	53	count = 0;
	54	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
	55	if (formats[i] == NULL)
	56	break;
	57
	58	err = snd_oxfw_stream_parse_format(formats[i], &formation);
	59	if (err < 0)
	60	continue;
	61	if (!snd_interval_test(r, formation.rate))
	62	continue;
	63	if (list[count] == formation.pcm)
	64	continue;
	65
	66	for (j = 0; j < ARRAY_SIZE(list); j++) {
	67	if (list[j] == formation.pcm)
	68	break;
	69	}
	70	if (j == ARRAY_SIZE(list)) {
	71	list[count] = formation.pcm;
	72	if (++count == ARRAY_SIZE(list))
	73	break;
	74	}
	75	}
	76
	77	return snd_interval_list(c, count, list, 0);
3713d93a TS	78	}
3713d93a TS	79
5cd1d3f4	80	static void limit_channels_and_rates(struct snd_pcm_hardware hw, u8 *formats)
3713d93a	81	{
5cd1d3f4 TS	82	struct snd_oxfw_stream_formation formation;
5cd1d3f4 TS	83	unsigned int i, err;
3713d93a	84
5cd1d3f4 TS	85	hw->channels_min = UINT_MAX;
5cd1d3f4 TS	86	hw->channels_max = 0;
3713d93a	87
5cd1d3f4 TS	88	hw->rate_min = UINT_MAX;
	89	hw->rate_max = 0;
	90	hw->rates = 0;
3713d93a	91
5cd1d3f4 TS	92	for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
	93	if (formats[i] == NULL)
	94	break;
	95
	96	err = snd_oxfw_stream_parse_format(formats[i], &formation);
	97	if (err < 0)
	98	continue;
	99
	100	hw->channels_min = min(hw->channels_min, formation.pcm);
	101	hw->channels_max = max(hw->channels_max, formation.pcm);
	102
	103	hw->rate_min = min(hw->rate_min, formation.rate);
	104	hw->rate_max = max(hw->rate_max, formation.rate);
	105	hw->rates \|= snd_pcm_rate_to_rate_bit(formation.rate);
	106	}
3713d93a TS	107	}
3713d93a TS	108
5cd1d3f4	109	static void limit_period_and_buffer(struct snd_pcm_hardware *hw)
3713d93a	110	{
5cd1d3f4 TS	111	hw->periods_min = 2; /* SNDRV_PCM_INFO_BATCH */
5cd1d3f4 TS	112	hw->periods_max = UINT_MAX;
3713d93a	113
5cd1d3f4 TS	114	hw->period_bytes_min = 4 * hw->channels_max; /* bytes for a frame */
	115
	116	/* Just to prevent from allocating much pages. */
	117	hw->period_bytes_max = hw->period_bytes_min * 2048;
	118	hw->buffer_bytes_max = hw->period_bytes_max * hw->periods_min;
3713d93a TS	119	}
	120
	121	static int pcm_open(struct snd_pcm_substream *substream)
	122	{
3713d93a TS	123	struct snd_oxfw *oxfw = substream->private_data;
3713d93a TS	124	struct snd_pcm_runtime *runtime = substream->runtime;
5cd1d3f4	125	u8 **formats;
3713d93a TS	126	int err;
3713d93a TS	127
5cd1d3f4 TS	128	formats = oxfw->rx_stream_formats;
	129
	130	runtime->hw.info = SNDRV_PCM_INFO_BATCH \|
	131	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	132	SNDRV_PCM_INFO_INTERLEAVED \|
	133	SNDRV_PCM_INFO_MMAP \|
	134	SNDRV_PCM_INFO_MMAP_VALID;
3713d93a	135
5cd1d3f4 TS	136	limit_channels_and_rates(&runtime->hw, formats);
5cd1d3f4 TS	137	limit_period_and_buffer(&runtime->hw);
3713d93a	138
5cd1d3f4 TS	139	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	140	hw_rule_channels, formats,
	141	SNDRV_PCM_HW_PARAM_RATE, -1);
3713d93a TS	142	if (err < 0)
3713d93a TS	143	goto end;
5cd1d3f4 TS	144
	145	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	146	hw_rule_rate, formats,
	147	SNDRV_PCM_HW_PARAM_CHANNELS, -1);
3713d93a TS	148	if (err < 0)
	149	goto end;
	150
	151	err = amdtp_stream_add_pcm_hw_constraints(&oxfw->rx_stream, runtime);
5cd1d3f4 TS	152	if (err < 0)
	153	goto end;
	154
	155	snd_pcm_set_sync(substream);
3713d93a TS	156	end:
	157	return err;
	158	}
	159
	160	static int pcm_close(struct snd_pcm_substream *substream)
	161	{
	162	return 0;
	163	}
	164
	165	static int pcm_hw_params(struct snd_pcm_substream *substream,
	166	struct snd_pcm_hw_params *hw_params)
	167	{
	168	struct snd_oxfw *oxfw = substream->private_data;
	169	int err;
	170
	171	mutex_lock(&oxfw->mutex);
	172
	173	snd_oxfw_stream_stop_simplex(oxfw);
	174
	175	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	176	params_buffer_bytes(hw_params));
	177	if (err < 0)
	178	goto error;
	179
	180	amdtp_stream_set_parameters(&oxfw->rx_stream,
	181	params_rate(hw_params),
	182	params_channels(hw_params),
	183	0);
	184
	185	amdtp_stream_set_pcm_format(&oxfw->rx_stream,
	186	params_format(hw_params));
	187
	188	err = avc_general_set_sig_fmt(oxfw->unit, params_rate(hw_params),
	189	AVC_GENERAL_PLUG_DIR_IN, 0);
	190	if (err < 0) {
	191	dev_err(&oxfw->unit->device, "failed to set sample rate\n");
	192	goto err_buffer;
	193	}
	194
	195	return 0;
	196
	197	err_buffer:
	198	snd_pcm_lib_free_vmalloc_buffer(substream);
	199	error:
	200	mutex_unlock(&oxfw->mutex);
	201	return err;
	202	}
	203
	204	static int pcm_hw_free(struct snd_pcm_substream *substream)
	205	{
	206	struct snd_oxfw *oxfw = substream->private_data;
	207
	208	mutex_lock(&oxfw->mutex);
	209	snd_oxfw_stream_stop_simplex(oxfw);
	210	mutex_unlock(&oxfw->mutex);
	211
	212	return snd_pcm_lib_free_vmalloc_buffer(substream);
	213	}
	214
	215	static int pcm_prepare(struct snd_pcm_substream *substream)
	216	{
	217	struct snd_oxfw *oxfw = substream->private_data;
	218	int err;
	219
220	mutex_lock(&oxfw->mutex);
221
222	snd_oxfw_stream_stop_simplex(oxfw);
223
224	err = snd_oxfw_stream_start_simplex(oxfw);
225	if (err < 0)
226	goto end;
227
228	amdtp_stream_pcm_prepare(&oxfw->rx_stream);
229	end:
230	mutex_unlock(&oxfw->mutex);
231	return err;
232	}
233
234	static int pcm_trigger(struct snd_pcm_substream *substream, int cmd)
235	{
236	struct snd_oxfw *oxfw = substream->private_data;
237	struct snd_pcm_substream *pcm;
238
239	switch (cmd) {
240	case SNDRV_PCM_TRIGGER_START:
241	pcm = substream;
242	break;
243	case SNDRV_PCM_TRIGGER_STOP:
244	pcm = NULL;
245	break;
246	default:
247	return -EINVAL;
248	}
249	amdtp_stream_pcm_trigger(&oxfw->rx_stream, pcm);
250	return 0;
251	}
252
253	static snd_pcm_uframes_t pcm_pointer(struct snd_pcm_substream *substream)
254	{
255	struct snd_oxfw *oxfw = substream->private_data;
256
257	return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
258	}
259
260	int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
261	{
262	static struct snd_pcm_ops ops = {
263	.open = pcm_open,
264	.close = pcm_close,
265	.ioctl = snd_pcm_lib_ioctl,
266	.hw_params = pcm_hw_params,
267	.hw_free = pcm_hw_free,
268	.prepare = pcm_prepare,
269	.trigger = pcm_trigger,
270	.pointer = pcm_pointer,
271	.page = snd_pcm_lib_get_vmalloc_page,
272	.mmap = snd_pcm_lib_mmap_vmalloc,
273	};
274	struct snd_pcm *pcm;
275	int err;
276
277	err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, 0, &pcm);
278	if (err < 0)
279	return err;
280	pcm->private_data = oxfw;
281	strcpy(pcm->name, oxfw->card->shortname);
282	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &ops);
283	return 0;
284	}