[mirror_ubuntu-jammy-kernel.git] / sound / firewire / fireface / ff-midi.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * ff-midi.c - a part of driver for RME Fireface series
 *
 * Copyright (c) 2015-2017 Takashi Sakamoto
 */

#include "ff.h"

static int midi_capture_open(struct snd_rawmidi_substream *substream)
{
	/* Do nothing. */
	return 0;
}

static int midi_playback_open(struct snd_rawmidi_substream *substream)
{
	struct snd_ff *ff = substream->rmidi->private_data;

	/* Initialize internal status. */
	ff->on_sysex[substream->number] = 0;
	ff->rx_midi_error[substream->number] = false;

	WRITE_ONCE(ff->rx_midi_substreams[substream->number], substream);

	return 0;
}

static int midi_capture_close(struct snd_rawmidi_substream *substream)
{
	/* Do nothing. */
	return 0;
}

static int midi_playback_close(struct snd_rawmidi_substream *substream)
{
	struct snd_ff *ff = substream->rmidi->private_data;

	cancel_work_sync(&ff->rx_midi_work[substream->number]);
	WRITE_ONCE(ff->rx_midi_substreams[substream->number], NULL);

	return 0;
}

static void midi_capture_trigger(struct snd_rawmidi_substream *substream,
				 int up)
{
	struct snd_ff *ff = substream->rmidi->private_data;
	unsigned long flags;

	spin_lock_irqsave(&ff->lock, flags);

	if (up)
		WRITE_ONCE(ff->tx_midi_substreams[substream->number],
			   substream);
	else
		WRITE_ONCE(ff->tx_midi_substreams[substream->number], NULL);

	spin_unlock_irqrestore(&ff->lock, flags);
}

static void midi_playback_trigger(struct snd_rawmidi_substream *substream,
				  int up)
{
	struct snd_ff *ff = substream->rmidi->private_data;
	unsigned long flags;

	spin_lock_irqsave(&ff->lock, flags);

	if (up || !ff->rx_midi_error[substream->number])
		schedule_work(&ff->rx_midi_work[substream->number]);

	spin_unlock_irqrestore(&ff->lock, flags);
}

static void set_midi_substream_names(struct snd_rawmidi_str *stream,
				     const char *const name)
{
	struct snd_rawmidi_substream *substream;

	list_for_each_entry(substream, &stream->substreams, list) {
		snprintf(substream->name, sizeof(substream->name),
			 "%s MIDI %d", name, substream->number + 1);
	}
}

int snd_ff_create_midi_devices(struct snd_ff *ff)
{
	static const struct snd_rawmidi_ops midi_capture_ops = {
		.open		= midi_capture_open,
		.close		= midi_capture_close,
		.trigger	= midi_capture_trigger,
	};
	static const struct snd_rawmidi_ops midi_playback_ops = {
		.open		= midi_playback_open,
		.close		= midi_playback_close,
		.trigger	= midi_playback_trigger,
	};
	struct snd_rawmidi *rmidi;
	struct snd_rawmidi_str *stream;
	int err;

	err = snd_rawmidi_new(ff->card, ff->card->driver, 0,
			      ff->spec->midi_out_ports, ff->spec->midi_in_ports,
			      &rmidi);
	if (err < 0)
		return err;

	snprintf(rmidi->name, sizeof(rmidi->name),
		 "%s MIDI", ff->card->shortname);
	rmidi->private_data = ff;

	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
			    &midi_capture_ops);
	stream = &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT];
	set_midi_substream_names(stream, ff->card->shortname);

	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
			    &midi_playback_ops);
	stream = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT];
	set_midi_substream_names(stream, ff->card->shortname);

	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;

	return 0;
}
Commit	Line	Data
da607e19	1	// SPDX-License-Identifier: GPL-2.0-only
ff2c293e TS	2	/*
	3	* ff-midi.c - a part of driver for RME Fireface series
	4	*
	5	* Copyright (c) 2015-2017 Takashi Sakamoto
ff2c293e TS	6	*/
	7
	8	#include "ff.h"
	9
	10	static int midi_capture_open(struct snd_rawmidi_substream *substream)
	11	{
	12	/* Do nothing. */
	13	return 0;
	14	}
	15
	16	static int midi_playback_open(struct snd_rawmidi_substream *substream)
	17	{
	18	struct snd_ff *ff = substream->rmidi->private_data;
	19
	20	/* Initialize internal status. */
f0f9f497	21	ff->on_sysex[substream->number] = 0;
ff2c293e TS	22	ff->rx_midi_error[substream->number] = false;
ff2c293e TS	23
6aa7de05	24	WRITE_ONCE(ff->rx_midi_substreams[substream->number], substream);
ff2c293e TS	25
	26	return 0;
	27	}
	28
	29	static int midi_capture_close(struct snd_rawmidi_substream *substream)
	30	{
	31	/* Do nothing. */
	32	return 0;
	33	}
	34
	35	static int midi_playback_close(struct snd_rawmidi_substream *substream)
	36	{
	37	struct snd_ff *ff = substream->rmidi->private_data;
	38
	39	cancel_work_sync(&ff->rx_midi_work[substream->number]);
6aa7de05	40	WRITE_ONCE(ff->rx_midi_substreams[substream->number], NULL);
ff2c293e TS	41
	42	return 0;
	43	}
	44
	45	static void midi_capture_trigger(struct snd_rawmidi_substream *substream,
	46	int up)
	47	{
	48	struct snd_ff *ff = substream->rmidi->private_data;
	49	unsigned long flags;
	50
	51	spin_lock_irqsave(&ff->lock, flags);
	52
	53	if (up)
6aa7de05 MR	54	WRITE_ONCE(ff->tx_midi_substreams[substream->number],
6aa7de05 MR	55	substream);
ff2c293e	56	else
6aa7de05	57	WRITE_ONCE(ff->tx_midi_substreams[substream->number], NULL);
ff2c293e TS	58
	59	spin_unlock_irqrestore(&ff->lock, flags);
	60	}
	61
	62	static void midi_playback_trigger(struct snd_rawmidi_substream *substream,
	63	int up)
	64	{
	65	struct snd_ff *ff = substream->rmidi->private_data;
	66	unsigned long flags;
	67
	68	spin_lock_irqsave(&ff->lock, flags);
	69
	70	if (up \|\| !ff->rx_midi_error[substream->number])
	71	schedule_work(&ff->rx_midi_work[substream->number]);
	72
	73	spin_unlock_irqrestore(&ff->lock, flags);
	74	}
	75
ff2c293e TS	76	static void set_midi_substream_names(struct snd_rawmidi_str *stream,
	77	const char *const name)
	78	{
	79	struct snd_rawmidi_substream *substream;
	80
	81	list_for_each_entry(substream, &stream->substreams, list) {
	82	snprintf(substream->name, sizeof(substream->name),
	83	"%s MIDI %d", name, substream->number + 1);
	84	}
	85	}
	86
	87	int snd_ff_create_midi_devices(struct snd_ff *ff)
	88	{
d2dc2a96 TS	89	static const struct snd_rawmidi_ops midi_capture_ops = {
	90	.open = midi_capture_open,
	91	.close = midi_capture_close,
	92	.trigger = midi_capture_trigger,
	93	};
	94	static const struct snd_rawmidi_ops midi_playback_ops = {
	95	.open = midi_playback_open,
	96	.close = midi_playback_close,
	97	.trigger = midi_playback_trigger,
	98	};
ff2c293e TS	99	struct snd_rawmidi *rmidi;
	100	struct snd_rawmidi_str *stream;
	101	int err;
	102
	103	err = snd_rawmidi_new(ff->card, ff->card->driver, 0,
	104	ff->spec->midi_out_ports, ff->spec->midi_in_ports,
	105	&rmidi);
	106	if (err < 0)
	107	return err;
	108
	109	snprintf(rmidi->name, sizeof(rmidi->name),
	110	"%s MIDI", ff->card->shortname);
	111	rmidi->private_data = ff;
	112
	113	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_INPUT;
	114	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
	115	&midi_capture_ops);
	116	stream = &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT];
	117	set_midi_substream_names(stream, ff->card->shortname);
	118
	119	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_OUTPUT;
	120	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
	121	&midi_playback_ops);
	122	stream = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT];
	123	set_midi_substream_names(stream, ff->card->shortname);
	124
	125	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_DUPLEX;
	126
	127	return 0;
	128	}