[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;
	struct amdtp_domain *d = &oxfw->domain;
	int err;

	err = snd_oxfw_stream_lock_try(oxfw);
	if (err < 0)
		return err;

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

	mutex_lock(&oxfw->mutex);

	// When source of clock is not internal or any stream is reserved for
	// transmission of PCM frames, the available sampling rate is limited
	// at current one.
	if (oxfw->substreams_count > 0 && d->events_per_period > 0) {
		unsigned int frames_per_period = d->events_per_period;

		err = limit_to_current_params(substream);
		if (err < 0) {
			mutex_unlock(&oxfw->mutex);
			goto err_locked;
		}

		if (frames_per_period > 0) {
			err = snd_pcm_hw_constraint_minmax(substream->runtime,
					SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
					frames_per_period, frames_per_period);
			if (err < 0) {
				mutex_unlock(&oxfw->mutex);
				goto err_locked;
			}
		}
	}

	mutex_unlock(&oxfw->mutex);

	snd_pcm_set_sync(substream);

	return 0;
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);
		unsigned int frames_per_period = params_period_size(hw_params);

		mutex_lock(&oxfw->mutex);
		err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->tx_stream,
					rate, channels, frames_per_period);
		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);
		unsigned int frames_per_period = params_period_size(hw_params);

		mutex_lock(&oxfw->mutex);
		err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->rx_stream,
					rate, channels, frames_per_period);
		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;
c0ede398	173	struct amdtp_domain *d = &oxfw->domain;
216e256f TS	174	int err;
216e256f TS	175
8985f4ac	176	err = snd_oxfw_stream_lock_try(oxfw);
5cd1d3f4	177	if (err < 0)
c0ede398	178	return err;
5cd1d3f4	179
8985f4ac TS	180	err = init_hw_params(oxfw, substream);
	181	if (err < 0)
	182	goto err_locked;
	183
c0ede398 TS	184	mutex_lock(&oxfw->mutex);
	185
	186	// When source of clock is not internal or any stream is reserved for
	187	// transmission of PCM frames, the available sampling rate is limited
	188	// at current one.
	189	if (oxfw->substreams_count > 0 && d->events_per_period > 0) {
	190	unsigned int frames_per_period = d->events_per_period;
	191
216e256f	192	err = limit_to_current_params(substream);
c0ede398 TS	193	if (err < 0) {
	194	mutex_unlock(&oxfw->mutex);
	195	goto err_locked;
	196	}
	197
	198	if (frames_per_period > 0) {
	199	err = snd_pcm_hw_constraint_minmax(substream->runtime,
	200	SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
	201	frames_per_period, frames_per_period);
	202	if (err < 0) {
	203	mutex_unlock(&oxfw->mutex);
	204	goto err_locked;
	205	}
	206	}
216e256f TS	207	}
216e256f TS	208
c0ede398 TS	209	mutex_unlock(&oxfw->mutex);
c0ede398 TS	210
5cd1d3f4	211	snd_pcm_set_sync(substream);
c0ede398 TS	212
c0ede398 TS	213	return 0;
8985f4ac TS	214	err_locked:
	215	snd_oxfw_stream_lock_release(oxfw);
	216	return err;
3713d93a TS	217	}
	218
	219	static int pcm_close(struct snd_pcm_substream *substream)
	220	{
8985f4ac TS	221	struct snd_oxfw *oxfw = substream->private_data;
	222
	223	snd_oxfw_stream_lock_release(oxfw);
3713d93a TS	224	return 0;
	225	}
	226
216e256f TS	227	static int pcm_capture_hw_params(struct snd_pcm_substream *substream,
216e256f TS	228	struct snd_pcm_hw_params *hw_params)
3713d93a TS	229	{
3713d93a TS	230	struct snd_oxfw *oxfw = substream->private_data;
22c103cd	231	int err;
3713d93a	232
22c103cd TS	233	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	234	params_buffer_bytes(hw_params));
	235	if (err < 0)
	236	return err;
216e256f TS	237
216e256f TS	238	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
4f380d00 TS	239	unsigned int rate = params_rate(hw_params);
4f380d00 TS	240	unsigned int channels = params_channels(hw_params);
1d6a722c	241	unsigned int frames_per_period = params_period_size(hw_params);
4f380d00	242
216e256f	243	mutex_lock(&oxfw->mutex);
4f380d00	244	err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->tx_stream,
1d6a722c	245	rate, channels, frames_per_period);
4f380d00 TS	246	if (err >= 0)
4f380d00 TS	247	++oxfw->substreams_count;
216e256f TS	248	mutex_unlock(&oxfw->mutex);
	249	}
	250
4f380d00	251	return err;
216e256f TS	252	}
	253	static int pcm_playback_hw_params(struct snd_pcm_substream *substream,
	254	struct snd_pcm_hw_params *hw_params)
	255	{
	256	struct snd_oxfw *oxfw = substream->private_data;
22c103cd TS	257	int err;
	258
	259	err = snd_pcm_lib_alloc_vmalloc_buffer(substream,
	260	params_buffer_bytes(hw_params));
	261	if (err < 0)
	262	return err;
216e256f TS	263
216e256f TS	264	if (substream->runtime->status->state == SNDRV_PCM_STATE_OPEN) {
4f380d00 TS	265	unsigned int rate = params_rate(hw_params);
4f380d00 TS	266	unsigned int channels = params_channels(hw_params);
1d6a722c	267	unsigned int frames_per_period = params_period_size(hw_params);
4f380d00	268
216e256f	269	mutex_lock(&oxfw->mutex);
2fd23293	270	err = snd_oxfw_stream_reserve_duplex(oxfw, &oxfw->rx_stream,
1d6a722c	271	rate, channels, frames_per_period);
4f380d00 TS	272	if (err >= 0)
4f380d00 TS	273	++oxfw->substreams_count;
216e256f TS	274	mutex_unlock(&oxfw->mutex);
	275	}
	276
22c103cd	277	return 0;
3713d93a TS	278	}
3713d93a TS	279
216e256f TS	280	static int pcm_capture_hw_free(struct snd_pcm_substream *substream)
	281	{
	282	struct snd_oxfw *oxfw = substream->private_data;
	283
	284	mutex_lock(&oxfw->mutex);
	285
	286	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
4a0a0472	287	--oxfw->substreams_count;
216e256f	288
779f0dba	289	snd_oxfw_stream_stop_duplex(oxfw);
216e256f TS	290
	291	mutex_unlock(&oxfw->mutex);
	292
	293	return snd_pcm_lib_free_vmalloc_buffer(substream);
	294	}
	295	static int pcm_playback_hw_free(struct snd_pcm_substream *substream)
3713d93a TS	296	{
	297	struct snd_oxfw *oxfw = substream->private_data;
	298
	299	mutex_lock(&oxfw->mutex);
216e256f TS	300
216e256f TS	301	if (substream->runtime->status->state != SNDRV_PCM_STATE_OPEN)
4a0a0472	302	--oxfw->substreams_count;
216e256f	303
779f0dba	304	snd_oxfw_stream_stop_duplex(oxfw);
216e256f	305
3713d93a TS	306	mutex_unlock(&oxfw->mutex);
	307
	308	return snd_pcm_lib_free_vmalloc_buffer(substream);
	309	}
	310
216e256f TS	311	static int pcm_capture_prepare(struct snd_pcm_substream *substream)
	312	{
	313	struct snd_oxfw *oxfw = substream->private_data;
216e256f TS	314	int err;
	315
	316	mutex_lock(&oxfw->mutex);
4f380d00	317	err = snd_oxfw_stream_start_duplex(oxfw);
216e256f TS	318	mutex_unlock(&oxfw->mutex);
	319	if (err < 0)
	320	goto end;
	321
	322	amdtp_stream_pcm_prepare(&oxfw->tx_stream);
	323	end:
	324	return err;
	325	}
	326	static int pcm_playback_prepare(struct snd_pcm_substream *substream)
3713d93a TS	327	{
	328	struct snd_oxfw *oxfw = substream->private_data;
	329	int err;
	330
	331	mutex_lock(&oxfw->mutex);
4f380d00	332	err = snd_oxfw_stream_start_duplex(oxfw);
f3699e2c	333	mutex_unlock(&oxfw->mutex);
3713d93a TS	334	if (err < 0)
	335	goto end;
	336
	337	amdtp_stream_pcm_prepare(&oxfw->rx_stream);
	338	end:
3713d93a TS	339	return err;
	340	}
	341
216e256f TS	342	static int pcm_capture_trigger(struct snd_pcm_substream *substream, int cmd)
	343	{
	344	struct snd_oxfw *oxfw = substream->private_data;
	345	struct snd_pcm_substream *pcm;
	346
	347	switch (cmd) {
	348	case SNDRV_PCM_TRIGGER_START:
	349	pcm = substream;
	350	break;
	351	case SNDRV_PCM_TRIGGER_STOP:
	352	pcm = NULL;
	353	break;
	354	default:
	355	return -EINVAL;
	356	}
	357	amdtp_stream_pcm_trigger(&oxfw->tx_stream, pcm);
	358	return 0;
	359	}
	360	static int pcm_playback_trigger(struct snd_pcm_substream *substream, int cmd)
3713d93a TS	361	{
	362	struct snd_oxfw *oxfw = substream->private_data;
	363	struct snd_pcm_substream *pcm;
	364
	365	switch (cmd) {
	366	case SNDRV_PCM_TRIGGER_START:
	367	pcm = substream;
	368	break;
	369	case SNDRV_PCM_TRIGGER_STOP:
	370	pcm = NULL;
	371	break;
	372	default:
	373	return -EINVAL;
	374	}
	375	amdtp_stream_pcm_trigger(&oxfw->rx_stream, pcm);
	376	return 0;
	377	}
	378
216e256f	379	static snd_pcm_uframes_t pcm_capture_pointer(struct snd_pcm_substream *sbstm)
3713d93a	380	{
216e256f TS	381	struct snd_oxfw *oxfw = sbstm->private_data;
	382
	383	return amdtp_stream_pcm_pointer(&oxfw->tx_stream);
	384	}
	385	static snd_pcm_uframes_t pcm_playback_pointer(struct snd_pcm_substream *sbstm)
	386	{
	387	struct snd_oxfw *oxfw = sbstm->private_data;
3713d93a TS	388
	389	return amdtp_stream_pcm_pointer(&oxfw->rx_stream);
	390	}
	391
875becf8 TS	392	static int pcm_capture_ack(struct snd_pcm_substream *substream)
	393	{
	394	struct snd_oxfw *oxfw = substream->private_data;
	395
	396	return amdtp_stream_pcm_ack(&oxfw->tx_stream);
	397	}
	398
	399	static int pcm_playback_ack(struct snd_pcm_substream *substream)
	400	{
	401	struct snd_oxfw *oxfw = substream->private_data;
	402
	403	return amdtp_stream_pcm_ack(&oxfw->rx_stream);
	404	}
	405
3713d93a TS	406	int snd_oxfw_create_pcm(struct snd_oxfw *oxfw)
3713d93a TS	407	{
5116ffc3	408	static const struct snd_pcm_ops capture_ops = {
216e256f TS	409	.open = pcm_open,
	410	.close = pcm_close,
	411	.ioctl = snd_pcm_lib_ioctl,
	412	.hw_params = pcm_capture_hw_params,
	413	.hw_free = pcm_capture_hw_free,
	414	.prepare = pcm_capture_prepare,
	415	.trigger = pcm_capture_trigger,
	416	.pointer = pcm_capture_pointer,
875becf8	417	.ack = pcm_capture_ack,
216e256f	418	.page = snd_pcm_lib_get_vmalloc_page,
216e256f	419	};
5116ffc3	420	static const struct snd_pcm_ops playback_ops = {
3713d93a TS	421	.open = pcm_open,
	422	.close = pcm_close,
	423	.ioctl = snd_pcm_lib_ioctl,
216e256f TS	424	.hw_params = pcm_playback_hw_params,
	425	.hw_free = pcm_playback_hw_free,
	426	.prepare = pcm_playback_prepare,
	427	.trigger = pcm_playback_trigger,
	428	.pointer = pcm_playback_pointer,
875becf8	429	.ack = pcm_playback_ack,
3713d93a	430	.page = snd_pcm_lib_get_vmalloc_page,
3713d93a TS	431	};
3713d93a TS	432	struct snd_pcm *pcm;
216e256f	433	unsigned int cap = 0;
3713d93a TS	434	int err;
3713d93a TS	435
216e256f TS	436	if (oxfw->has_output)
	437	cap = 1;
	438
	439	err = snd_pcm_new(oxfw->card, oxfw->card->driver, 0, 1, cap, &pcm);
3713d93a TS	440	if (err < 0)
3713d93a TS	441	return err;
216e256f	442
3713d93a TS	443	pcm->private_data = oxfw;
3713d93a TS	444	strcpy(pcm->name, oxfw->card->shortname);
216e256f TS	445	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_ops);
	446	if (cap > 0)
	447	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_ops);
	448
3713d93a TS	449	return 0;
3713d93a TS	450	}