[mirror_ubuntu-zesty-kernel.git] / sound / firewire / tascam / tascam-midi.c

/*
 * tascam-midi.c - a part of driver for TASCAM FireWire series
 *
 * Copyright (c) 2015 Takashi Sakamoto
 *
 * Licensed under the terms of the GNU General Public License, version 2.
 */

#include "tascam.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_tscm *tscm = substream->rmidi->private_data;

	/* Initialize internal status. */
	tscm->running_status[substream->number] = 0;
	tscm->on_sysex[substream->number] = 0;
	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_tscm *tscm = substream->rmidi->private_data;

	snd_fw_async_midi_port_finish(&tscm->out_ports[substream->number]);

	return 0;
}

static void midi_capture_trigger(struct snd_rawmidi_substream *substrm, int up)
{
	struct snd_tscm *tscm = substrm->rmidi->private_data;
	unsigned long flags;

	spin_lock_irqsave(&tscm->lock, flags);

	if (up)
		tscm->tx_midi_substreams[substrm->number] = substrm;
	else
		tscm->tx_midi_substreams[substrm->number] = NULL;

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

static void midi_playback_trigger(struct snd_rawmidi_substream *substrm, int up)
{
	struct snd_tscm *tscm = substrm->rmidi->private_data;
	unsigned long flags;

	spin_lock_irqsave(&tscm->lock, flags);

	if (up)
		snd_fw_async_midi_port_run(&tscm->out_ports[substrm->number],
					   substrm);

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

static struct snd_rawmidi_ops midi_capture_ops = {
	.open		= midi_capture_open,
	.close		= midi_capture_close,
	.trigger	= midi_capture_trigger,
};

static struct snd_rawmidi_ops midi_playback_ops = {
	.open		= midi_playback_open,
	.close		= midi_playback_close,
	.trigger	= midi_playback_trigger,
};

int snd_tscm_create_midi_devices(struct snd_tscm *tscm)
{
	struct snd_rawmidi *rmidi;
	struct snd_rawmidi_str *stream;
	struct snd_rawmidi_substream *subs;
	int err;

	err = snd_rawmidi_new(tscm->card, tscm->card->driver, 0,
			      tscm->spec->midi_playback_ports,
			      tscm->spec->midi_capture_ports,
			      &rmidi);
	if (err < 0)
		return err;

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

	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 port names for MIDI input. */
	list_for_each_entry(subs, &stream->substreams, list) {
		/* TODO: support virtual MIDI ports. */
		if (subs->number < tscm->spec->midi_capture_ports) {
			/* Hardware MIDI ports. */
			snprintf(subs->name, sizeof(subs->name),
				 "%s MIDI %d",
				 tscm->card->shortname, subs->number + 1);
		}
	}

	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 port names for MIDI ourput. */
	list_for_each_entry(subs, &stream->substreams, list) {
		if (subs->number < tscm->spec->midi_playback_ports) {
			/* Hardware MIDI ports only. */
			snprintf(subs->name, sizeof(subs->name),
				 "%s MIDI %d",
				 tscm->card->shortname, subs->number + 1);
		}
	}

	rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;

	return 0;
}
Commit	Line	Data
0db18e7e TS	1	/*
	2	* tascam-midi.c - a part of driver for TASCAM FireWire series
	3	*
	4	* Copyright (c) 2015 Takashi Sakamoto
	5	*
	6	* Licensed under the terms of the GNU General Public License, version 2.
	7	*/
	8
	9	#include "tascam.h"
	10
	11	static int midi_capture_open(struct snd_rawmidi_substream *substream)
	12	{
	13	/* Do nothing. */
	14	return 0;
	15	}
	16
	17	static int midi_playback_open(struct snd_rawmidi_substream *substream)
	18	{
	19	struct snd_tscm *tscm = substream->rmidi->private_data;
	20
	21	/* Initialize internal status. */
	22	tscm->running_status[substream->number] = 0;
	23	tscm->on_sysex[substream->number] = 0;
	24	return 0;
	25	}
	26
	27	static int midi_capture_close(struct snd_rawmidi_substream *substream)
	28	{
	29	/* Do nothing. */
	30	return 0;
	31	}
	32
	33	static int midi_playback_close(struct snd_rawmidi_substream *substream)
	34	{
	35	struct snd_tscm *tscm = substream->rmidi->private_data;
	36
	37	snd_fw_async_midi_port_finish(&tscm->out_ports[substream->number]);
	38
	39	return 0;
	40	}
	41
	42	static void midi_capture_trigger(struct snd_rawmidi_substream *substrm, int up)
	43	{
	44	struct snd_tscm *tscm = substrm->rmidi->private_data;
	45	unsigned long flags;
	46
	47	spin_lock_irqsave(&tscm->lock, flags);
	48
	49	if (up)
	50	tscm->tx_midi_substreams[substrm->number] = substrm;
	51	else
	52	tscm->tx_midi_substreams[substrm->number] = NULL;
	53
	54	spin_unlock_irqrestore(&tscm->lock, flags);
	55	}
	56
	57	static void midi_playback_trigger(struct snd_rawmidi_substream *substrm, int up)
	58	{
	59	struct snd_tscm *tscm = substrm->rmidi->private_data;
	60	unsigned long flags;
	61
	62	spin_lock_irqsave(&tscm->lock, flags);
	63
	64	if (up)
65	snd_fw_async_midi_port_run(&tscm->out_ports[substrm->number],
66	substrm);
67
68	spin_unlock_irqrestore(&tscm->lock, flags);
69	}
70
71	static struct snd_rawmidi_ops midi_capture_ops = {
72	.open = midi_capture_open,
73	.close = midi_capture_close,
74	.trigger = midi_capture_trigger,
75	};
76
77	static struct snd_rawmidi_ops midi_playback_ops = {
78	.open = midi_playback_open,
79	.close = midi_playback_close,
80	.trigger = midi_playback_trigger,
81	};
82
83	int snd_tscm_create_midi_devices(struct snd_tscm *tscm)
84	{
85	struct snd_rawmidi *rmidi;
86	struct snd_rawmidi_str *stream;
87	struct snd_rawmidi_substream *subs;
88	int err;
89
90	err = snd_rawmidi_new(tscm->card, tscm->card->driver, 0,
91	tscm->spec->midi_playback_ports,
92	tscm->spec->midi_capture_ports,
93	&rmidi);
94	if (err < 0)
95	return err;
96
97	snprintf(rmidi->name, sizeof(rmidi->name),
98	"%s MIDI", tscm->card->shortname);
99	rmidi->private_data = tscm;
100
101	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_INPUT;
102	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
103	&midi_capture_ops);
104	stream = &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT];
105
106	/* Set port names for MIDI input. */
107	list_for_each_entry(subs, &stream->substreams, list) {
108	/* TODO: support virtual MIDI ports. */
109	if (subs->number < tscm->spec->midi_capture_ports) {
110	/* Hardware MIDI ports. */
111	snprintf(subs->name, sizeof(subs->name),
112	"%s MIDI %d",
113	tscm->card->shortname, subs->number + 1);
114	}
115	}
116
117	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_OUTPUT;
118	snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
119	&midi_playback_ops);
120	stream = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT];
121
122	/* Set port names for MIDI ourput. */
123	list_for_each_entry(subs, &stream->substreams, list) {
124	if (subs->number < tscm->spec->midi_playback_ports) {
125	/* Hardware MIDI ports only. */
126	snprintf(subs->name, sizeof(subs->name),
127	"%s MIDI %d",
128	tscm->card->shortname, subs->number + 1);
129	}
130	}
131
132	rmidi->info_flags \|= SNDRV_RAWMIDI_INFO_DUPLEX;
133
134	return 0;
135	}