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

// SPDX-License-Identifier: GPL-2.0-only
/*
 * oxfw_pcm.c - a part of driver for OXFW970/971 based devices
 *
 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
 */

#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;
	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;
	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;
	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 int init_hw_params(struct snd_oxfw *oxfw,
			  struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	u8 **formats;
	struct amdtp_stream *stream;
	int err;

	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
		runtime->hw.formats = AM824_IN_PCM_FORMAT_BITS;
		stream = &oxfw->tx_stream;
		formats = oxfw->tx_stream_formats;
	} else {
		runtime->hw.formats = AM824_OUT_PCM_FORMAT_BITS;
		stream = &oxfw->rx_stream;
		formats = oxfw->rx_stream_formats;
	}

	limit_channels_and_rates(&runtime->hw, formats);

	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_am824_add_pcm_hw_constraints(stream, runtime);
end:
	return err;
}

static int limit_to_current_params(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;
	struct snd_oxfw_stream_formation formation;
	enum avc_general_plug_dir dir;
	int err;

	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
		dir = AVC_GENERAL_PLUG_DIR_OUT;
	else
		dir = AVC_GENERAL_PLUG_DIR_IN;

	err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
	if (err < 0)
		goto end;

	substream->runtime->hw.channels_min = formation.pcm;
	substream->runtime->hw.channels_max = formation.pcm;
	substream->runtime->hw.rate_min = formation.rate;
	substream->runtime->hw.rate_max = formation.rate;
end:
	return err;
}

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

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

	err = init_hw_params(oxfw, substream);
	if (err < 0)
		goto err_locked;

	/*
	 * When any PCM streams are already running, the available sampling
	 * rate is limited at current value.
	 */
	if (amdtp_stream_pcm_running(&oxfw->tx_stream) ||
	    amdtp_stream_pcm_running(&oxfw->rx_stream)) {
		err = limit_to_current_params(substream);
		if (err < 0)
			goto end;
	}

	snd_pcm_set_sync(substream);
end:
	return err;
err_locked:
	snd_oxfw_stream_lock_release(oxfw);
	return err;
}

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

	snd_oxfw_stream_lock_release(oxfw);
	return 0;
}

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

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

	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
		unsigned int rate = params_rate(hw_params);
		unsigned int channels = params_channels(hw_params);

		mutex_lock(&oxfw->mutex);
		err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->tx_stream,
						     rate, channels);
		if (err >= 0)
			++oxfw->substreams_count;
		mutex_unlock(&oxfw->mutex);
	}

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

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

	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
		unsigned int rate = params_rate(hw_params);
		unsigned int channels = params_channels(hw_params);

		mutex_lock(&oxfw->mutex);
		err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->rx_stream,
						     rate, channels);
		if (err >= 0)
			++oxfw->substreams_count;
		mutex_unlock(&oxfw->mutex);
	}

	return 0;
}

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

	mutex_lock(&oxfw->mutex);

	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
		--oxfw->substreams_count;

	snd_oxfw_stream_stop_duplex(oxfw);

	mutex_unlock(&oxfw->mutex);

	return snd_pcm_lib_free_vmalloc_buffer(substream);
}
static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;

	mutex_lock(&oxfw->mutex);

	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
		--oxfw->substreams_count;

	snd_oxfw_stream_stop_duplex(oxfw);

	mutex_unlock(&oxfw->mutex);

	return snd_pcm_lib_free_vmalloc_buffer(substream);
}

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

	mutex_lock(&oxfw->mutex);
	err = snd_oxfw_stream_start_duplex(oxfw);
	mutex_unlock(&oxfw->mutex);
	if (err < 0)
		goto end;

	amdtp_stream_pcm_prepare(&oxfw->tx_stream);
end:
	return err;
}
static int pcm_playback_prepare(struct snd_pcm_substream *substream)
{
	struct snd_oxfw *oxfw = substream->private_data;
	int err;

	mutex_lock(&oxfw->mutex);
	err = snd_oxfw_stream_start_duplex(oxfw);
	mutex_unlock(&oxfw->mutex);
	if (err < 0)
		goto end;

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

static int pcm_capture_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->tx_stream, pcm);
	return 0;
}
static int pcm_playback_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_capture_pointer(struct snd_pcm_substream *sbstm)
{
	struct snd_oxfw *oxfw = sbstm->private_data;

	return amdtp_stream_pcm_pointer(&oxfw->tx_stream);
}
static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstm)
{
	struct snd_oxfw *oxfw = sbstm->private_data;

	return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
}

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

	return amdtp_stream_pcm_ack(&oxfw->tx_stream);
}

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

	return amdtp_stream_pcm_ack(&oxfw->rx_stream);
}

int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
{
	static const struct snd_pcm_ops capture_ops = {
		.open      = pcm_open,
		.close     = pcm_close,
		.ioctl     = snd_pcm_lib_ioctl,
		.hw_params = pcm_capture_hw_params,
		.hw_free   = pcm_capture_hw_free,
		.prepare   = pcm_capture_prepare,
		.trigger   = pcm_capture_trigger,
		.pointer   = pcm_capture_pointer,
		.ack       = pcm_capture_ack,
		.page      = snd_pcm_lib_get_vmalloc_page,
	};
	static const struct snd_pcm_ops playback_ops = {
		.open      = pcm_open,
		.close     = pcm_close,
		.ioctl     = snd_pcm_lib_ioctl,
		.hw_params = pcm_playback_hw_params,
		.hw_free   = pcm_playback_hw_free,
		.prepare   = pcm_playback_prepare,
		.trigger   = pcm_playback_trigger,
		.pointer   = pcm_playback_pointer,
		.ack       = pcm_playback_ack,
		.page      = snd_pcm_lib_get_vmalloc_page,
	};
	struct snd_pcm *pcm;
	unsigned int cap = 0;
	int err;

	if (oxfw->has_output)
		cap = 1;

	err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, cap, &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, &playback_ops);
	if (cap > 0)
		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);

	return 0;
}
Commit	Line	Data
da607e19	1	// SPDX-License-Identifier: GPL-2.0-only
3713d93a TS	2	/*
	3	* oxfw_pcm.c - a part of driver for OXFW970/971 based devices
	4	*
	5	* Copyright (c) Clemens Ladisch <clemens@ladisch.de>
3713d93a TS	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;
5580ba7b	22	int i, err;
5cd1d3f4 TS	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;
5580ba7b	50	int i, j, err;
5cd1d3f4 TS	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	82	struct snd_oxfw_stream_formation formation;
5580ba7b	83	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
216e256f TS	109	static int init_hw_params(struct snd_oxfw *oxfw,
216e256f TS	110	struct snd_pcm_substream *substream)
3713d93a	111	{
3713d93a	112	struct snd_pcm_runtime *runtime = substream->runtime;
5cd1d3f4	113	u8 **formats;
216e256f	114	struct amdtp_stream *stream;
3713d93a TS	115	int err;
3713d93a TS	116
216e256f	117	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
49c7b3fc	118	runtime->hw.formats = AM824_IN_PCM_FORMAT_BITS;
216e256f TS	119	stream = &oxfw->tx_stream;
	120	formats = oxfw->tx_stream_formats;
	121	} else {
49c7b3fc	122	runtime->hw.formats = AM824_OUT_PCM_FORMAT_BITS;
216e256f TS	123	stream = &oxfw->rx_stream;
	124	formats = oxfw->rx_stream_formats;
	125	}
	126
5cd1d3f4	127	limit_channels_and_rates(&runtime->hw, formats);
3713d93a	128
5cd1d3f4 TS	129	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
	130	hw_rule_channels, formats,
	131	SNDRV_PCM_HW_PARAM_RATE, -1);
3713d93a TS	132	if (err < 0)
3713d93a TS	133	goto end;
5cd1d3f4 TS	134
	135	err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
	136	hw_rule_rate, formats,
	137	SNDRV_PCM_HW_PARAM_CHANNELS, -1);
3713d93a TS	138	if (err < 0)
	139	goto end;
	140
bc8500da	141	err = amdtp_am824_add_pcm_hw_constraints(stream, runtime);
216e256f TS	142	end:
	143	return err;
	144	}
	145
	146	static int limit_to_current_params(struct snd_pcm_substream *substream)
	147	{
	148	struct snd_oxfw *oxfw = substream->private_data;
	149	struct snd_oxfw_stream_formation formation;
	150	enum avc_general_plug_dir dir;
	151	int err;
	152
	153	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
	154	dir = AVC_GENERAL_PLUG_DIR_OUT;
	155	else
	156	dir = AVC_GENERAL_PLUG_DIR_IN;
	157
	158	err = snd_oxfw_stream_get_current_formation(oxfw, dir, &formation);
	159	if (err < 0)
	160	goto end;
	161
	162	substream->runtime->hw.channels_min = formation.pcm;
	163	substream->runtime->hw.channels_max = formation.pcm;
	164	substream->runtime->hw.rate_min = formation.rate;
	165	substream->runtime->hw.rate_max = formation.rate;
	166	end:
	167	return err;
	168	}
	169
	170	static int pcm_open(struct snd_pcm_substream *substream)
	171	{
	172	struct snd_oxfw *oxfw = substream->private_data;
	173	int err;
	174
8985f4ac	175	err = snd_oxfw_stream_lock_try(oxfw);
5cd1d3f4 TS	176	if (err < 0)
	177	goto end;
	178
8985f4ac TS	179	err = init_hw_params(oxfw, substream);
	180	if (err < 0)
	181	goto err_locked;
	182
216e256f TS	183	/*
	184	* When any PCM streams are already running, the available sampling
	185	* rate is limited at current value.
	186	*/
	187	if (amdtp_stream_pcm_running(&oxfw->tx_stream) \|\|
	188	amdtp_stream_pcm_running(&oxfw->rx_stream)) {
	189	err = limit_to_current_params(substream);
	190	if (err < 0)
	191	goto end;
	192	}
	193
5cd1d3f4	194	snd_pcm_set_sync(substream);
3713d93a TS	195	end:
3713d93a TS	196	return err;
8985f4ac TS	197	err_locked:
	198	snd_oxfw_stream_lock_release(oxfw);
	199	return err;
3713d93a TS	200	}
	201
	202	static int pcm_close(struct snd_pcm_substream *substream)
	203	{
8985f4ac TS	204	struct snd_oxfw *oxfw = substream->private_data;
	205
	206	snd_oxfw_stream_lock_release(oxfw);
3713d93a TS	207	return 0;
	208	}
	209
216e256f TS	210	static int pcm_capture_hw_params(struct snd_pcm_substream *substream,
216e256f TS	211	struct snd_pcm_hw_params *hw_params)
3713d93a TS	212	{
3713d93a TS	213	struct snd_oxfw *oxfw = substream->private_data;
22c103cd	214	int err;
3713d93a	215
22c103cd TS	216	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	217	params_buffer_bytes(hw_params));
	218	if (err < 0)
	219	return err;
216e256f TS	220
216e256f TS	221	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
4f380d00 TS	222	unsigned int rate = params_rate(hw_params);
	223	unsigned int channels = params_channels(hw_params);
	224
216e256f	225	mutex_lock(&oxfw->mutex);
4f380d00 TS	226	err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->tx_stream,
	227	rate, channels);
	228	if (err >= 0)
	229	++oxfw->substreams_count;
216e256f TS	230	mutex_unlock(&oxfw->mutex);
	231	}
	232
4f380d00	233	return err;
216e256f TS	234	}
	235	static int pcm_playback_hw_params(struct snd_pcm_substream *substream,
	236	struct snd_pcm_hw_params *hw_params)
	237	{
	238	struct snd_oxfw *oxfw = substream->private_data;
22c103cd TS	239	int err;
	240
	241	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	242	params_buffer_bytes(hw_params));
	243	if (err < 0)
	244	return err;
216e256f TS	245
216e256f TS	246	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
4f380d00 TS	247	unsigned int rate = params_rate(hw_params);
	248	unsigned int channels = params_channels(hw_params);
	249
216e256f	250	mutex_lock(&oxfw->mutex);
2fd23293	251	err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->rx_stream,
4f380d00 TS	252	rate, channels);
	253	if (err >= 0)
	254	++oxfw->substreams_count;
216e256f TS	255	mutex_unlock(&oxfw->mutex);
	256	}
	257
22c103cd	258	return 0;
3713d93a TS	259	}
3713d93a TS	260
216e256f TS	261	static int pcm_capture_hw_free(struct snd_pcm_substream *substream)
	262	{
	263	struct snd_oxfw *oxfw = substream->private_data;
	264
	265	mutex_lock(&oxfw->mutex);
	266
	267	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
4a0a0472	268	--oxfw->substreams_count;
216e256f	269
779f0dba	270	snd_oxfw_stream_stop_duplex(oxfw);
216e256f TS	271
	272	mutex_unlock(&oxfw->mutex);
	273
	274	return snd_pcm_lib_free_vmalloc_buffer(substream);
	275	}
	276	static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
3713d93a TS	277	{
	278	struct snd_oxfw *oxfw = substream->private_data;
	279
	280	mutex_lock(&oxfw->mutex);
216e256f TS	281
216e256f TS	282	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
4a0a0472	283	--oxfw->substreams_count;
216e256f	284
779f0dba	285	snd_oxfw_stream_stop_duplex(oxfw);
216e256f	286
3713d93a TS	287	mutex_unlock(&oxfw->mutex);
	288
	289	return snd_pcm_lib_free_vmalloc_buffer(substream);
	290	}
	291
216e256f TS	292	static int pcm_capture_prepare(struct snd_pcm_substream *substream)
	293	{
	294	struct snd_oxfw *oxfw = substream->private_data;
216e256f TS	295	int err;
	296
	297	mutex_lock(&oxfw->mutex);
4f380d00	298	err = snd_oxfw_stream_start_duplex(oxfw);
216e256f TS	299	mutex_unlock(&oxfw->mutex);
	300	if (err < 0)
	301	goto end;
	302
	303	amdtp_stream_pcm_prepare(&oxfw->tx_stream);
	304	end:
	305	return err;
	306	}
	307	static int pcm_playback_prepare(struct snd_pcm_substream *substream)
3713d93a TS	308	{
	309	struct snd_oxfw *oxfw = substream->private_data;
	310	int err;
	311
	312	mutex_lock(&oxfw->mutex);
4f380d00	313	err = snd_oxfw_stream_start_duplex(oxfw);
f3699e2c	314	mutex_unlock(&oxfw->mutex);
3713d93a TS	315	if (err < 0)
	316	goto end;
	317
	318	amdtp_stream_pcm_prepare(&oxfw->rx_stream);
	319	end:
3713d93a TS	320	return err;
	321	}
	322
216e256f TS	323	static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
	324	{
	325	struct snd_oxfw *oxfw = substream->private_data;
	326	struct snd_pcm_substream *pcm;
	327
	328	switch (cmd) {
	329	case SNDRV_PCM_TRIGGER_START:
	330	pcm = substream;
	331	break;
	332	case SNDRV_PCM_TRIGGER_STOP:
	333	pcm = NULL;
	334	break;
	335	default:
	336	return -EINVAL;
	337	}
	338	amdtp_stream_pcm_trigger(&oxfw->tx_stream, pcm);
	339	return 0;
	340	}
	341	static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
3713d93a TS	342	{
	343	struct snd_oxfw *oxfw = substream->private_data;
	344	struct snd_pcm_substream *pcm;
	345
	346	switch (cmd) {
	347	case SNDRV_PCM_TRIGGER_START:
	348	pcm = substream;
	349	break;
	350	case SNDRV_PCM_TRIGGER_STOP:
	351	pcm = NULL;
	352	break;
	353	default:
	354	return -EINVAL;
	355	}
	356	amdtp_stream_pcm_trigger(&oxfw->rx_stream, pcm);
	357	return 0;
	358	}
	359
216e256f	360	static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstm)
3713d93a	361	{
216e256f TS	362	struct snd_oxfw *oxfw = sbstm->private_data;
	363
	364	return amdtp_stream_pcm_pointer(&oxfw->tx_stream);
	365	}
	366	static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstm)
	367	{
	368	struct snd_oxfw *oxfw = sbstm->private_data;
3713d93a TS	369
	370	return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
	371	}
	372
875becf8 TS	373	static int pcm_capture_ack(struct snd_pcm_substream *substream)
	374	{
	375	struct snd_oxfw *oxfw = substream->private_data;
	376
	377	return amdtp_stream_pcm_ack(&oxfw->tx_stream);
	378	}
	379
	380	static int pcm_playback_ack(struct snd_pcm_substream *substream)
	381	{
	382	struct snd_oxfw *oxfw = substream->private_data;
	383
	384	return amdtp_stream_pcm_ack(&oxfw->rx_stream);
	385	}
	386
3713d93a TS	387	int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
3713d93a TS	388	{
5116ffc3	389	static const struct snd_pcm_ops capture_ops = {
216e256f TS	390	.open = pcm_open,
	391	.close = pcm_close,
	392	.ioctl = snd_pcm_lib_ioctl,
	393	.hw_params = pcm_capture_hw_params,
	394	.hw_free = pcm_capture_hw_free,
	395	.prepare = pcm_capture_prepare,
	396	.trigger = pcm_capture_trigger,
	397	.pointer = pcm_capture_pointer,
875becf8	398	.ack = pcm_capture_ack,
216e256f	399	.page = snd_pcm_lib_get_vmalloc_page,
216e256f	400	};
5116ffc3	401	static const struct snd_pcm_ops playback_ops = {
3713d93a TS	402	.open = pcm_open,
	403	.close = pcm_close,
	404	.ioctl = snd_pcm_lib_ioctl,
216e256f TS	405	.hw_params = pcm_playback_hw_params,
	406	.hw_free = pcm_playback_hw_free,
	407	.prepare = pcm_playback_prepare,
	408	.trigger = pcm_playback_trigger,
	409	.pointer = pcm_playback_pointer,
875becf8	410	.ack = pcm_playback_ack,
3713d93a	411	.page = snd_pcm_lib_get_vmalloc_page,
3713d93a TS	412	};
3713d93a TS	413	struct snd_pcm *pcm;
216e256f	414	unsigned int cap = 0;
3713d93a TS	415	int err;
3713d93a TS	416
216e256f TS	417	if (oxfw->has_output)
	418	cap = 1;
	419
	420	err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, cap, &pcm);
3713d93a TS	421	if (err < 0)
3713d93a TS	422	return err;
216e256f	423
3713d93a TS	424	pcm->private_data = oxfw;
3713d93a TS	425	strcpy(pcm->name, oxfw->card->shortname);
216e256f TS	426	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);
	427	if (cap > 0)
	428	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);
	429
3713d93a TS	430	return 0;
3713d93a TS	431	}