firewire/dice/dice-midi.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * dice_midi.c - a part of driver for Dice based devices
0004  *
0005  * Copyright (c) 2014 Takashi Sakamoto
0006  */
0007 #include "dice.h"
0008
0009 static int midi_open(struct snd_rawmidi_substream *substream)
0010 {
0011     struct snd_dice *dice = substream->rmidi->private_data;
0012     int err;
0013
0014     err = snd_dice_stream_lock_try(dice);
0015     if (err < 0)
0016         return err;
0017
0018     mutex_lock(&dice->mutex);
0019
0020     err = snd_dice_stream_reserve_duplex(dice, 0, 0, 0);
0021     if (err >= 0) {
0022         ++dice->substreams_counter;
0023         err = snd_dice_stream_start_duplex(dice);
0024         if (err < 0)
0025             --dice->substreams_counter;
0026     }
0027
0028     mutex_unlock(&dice->mutex);
0029
0030     if (err < 0)
0031         snd_dice_stream_lock_release(dice);
0032
0033     return err;
0034 }
0035
0036 static int midi_close(struct snd_rawmidi_substream *substream)
0037 {
0038     struct snd_dice *dice = substream->rmidi->private_data;
0039
0040     mutex_lock(&dice->mutex);
0041
0042     --dice->substreams_counter;
0043     snd_dice_stream_stop_duplex(dice);
0044
0045     mutex_unlock(&dice->mutex);
0046
0047     snd_dice_stream_lock_release(dice);
0048     return 0;
0049 }
0050
0051 static void midi_capture_trigger(struct snd_rawmidi_substream *substrm, int up)
0052 {
0053     struct snd_dice *dice = substrm->rmidi->private_data;
0054     unsigned long flags;
0055
0056     spin_lock_irqsave(&dice->lock, flags);
0057
0058     if (up)
0059         amdtp_am824_midi_trigger(&dice->tx_stream[0],
0060                       substrm->number, substrm);
0061     else
0062         amdtp_am824_midi_trigger(&dice->tx_stream[0],
0063                       substrm->number, NULL);
0064
0065     spin_unlock_irqrestore(&dice->lock, flags);
0066 }
0067
0068 static void midi_playback_trigger(struct snd_rawmidi_substream *substrm, int up)
0069 {
0070     struct snd_dice *dice = substrm->rmidi->private_data;
0071     unsigned long flags;
0072
0073     spin_lock_irqsave(&dice->lock, flags);
0074
0075     if (up)
0076         amdtp_am824_midi_trigger(&dice->rx_stream[0],
0077                      substrm->number, substrm);
0078     else
0079         amdtp_am824_midi_trigger(&dice->rx_stream[0],
0080                      substrm->number, NULL);
0081
0082     spin_unlock_irqrestore(&dice->lock, flags);
0083 }
0084
0085 static void set_midi_substream_names(struct snd_dice *dice,
0086                      struct snd_rawmidi_str *str)
0087 {
0088     struct snd_rawmidi_substream *subs;
0089
0090     list_for_each_entry(subs, &str->substreams, list) {
0091         snprintf(subs->name, sizeof(subs->name),
0092              "%s MIDI %d", dice->card->shortname, subs->number + 1);
0093     }
0094 }
0095
0096 int snd_dice_create_midi(struct snd_dice *dice)
0097 {
0098     static const struct snd_rawmidi_ops capture_ops = {
0099         .open       = midi_open,
0100         .close      = midi_close,
0101         .trigger    = midi_capture_trigger,
0102     };
0103     static const struct snd_rawmidi_ops playback_ops = {
0104         .open       = midi_open,
0105         .close      = midi_close,
0106         .trigger    = midi_playback_trigger,
0107     };
0108     struct snd_rawmidi *rmidi;
0109     struct snd_rawmidi_str *str;
0110     unsigned int midi_in_ports, midi_out_ports;
0111     int i;
0112     int err;
0113
0114     midi_in_ports = 0;
0115     midi_out_ports = 0;
0116     for (i = 0; i < MAX_STREAMS; ++i) {
0117         midi_in_ports = max(midi_in_ports, dice->tx_midi_ports[i]);
0118         midi_out_ports = max(midi_out_ports, dice->rx_midi_ports[i]);
0119     }
0120
0121     if (midi_in_ports + midi_out_ports == 0)
0122         return 0;
0123
0124     /* create midi ports */
0125     err = snd_rawmidi_new(dice->card, dice->card->driver, 0,
0126                   midi_out_ports, midi_in_ports,
0127                   &rmidi);
0128     if (err < 0)
0129         return err;
0130
0131     snprintf(rmidi->name, sizeof(rmidi->name),
0132          "%s MIDI", dice->card->shortname);
0133     rmidi->private_data = dice;
0134
0135     if (midi_in_ports > 0) {
0136         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
0137
0138         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
0139                     &capture_ops);
0140
0141         str = &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT];
0142
0143         set_midi_substream_names(dice, str);
0144     }
0145
0146     if (midi_out_ports > 0) {
0147         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
0148
0149         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
0150                     &playback_ops);
0151
0152         str = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT];
0153
0154         set_midi_substream_names(dice, str);
0155     }
0156
0157     if ((midi_out_ports > 0) && (midi_in_ports > 0))
0158         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
0159
0160     return 0;
0161 }