sound/firewire/oxfw/oxfw-midi.c

   1 /*
   2  * oxfw_midi.c - a part of driver for OXFW970/971 based devices
   3  *
   4  * Copyright (c) 2014 Takashi Sakamoto
   5  *
   6  * Licensed under the terms of the GNU General Public License, version 2.
   7  */
   8
   9 #include "oxfw.h"
  10
  11 static int midi_capture_open(struct snd_rawmidi_substream *substream)
  12 {
  13         struct snd_oxfw *oxfw = substream->rmidi->private_data;
  14         int err;
  15
  16         err = snd_oxfw_stream_lock_try(oxfw);
  17         if (err < 0)
  18                 return err;
  19
  20         mutex_lock(&oxfw->mutex);
  21
  22         oxfw->capture_substreams++;
  23         err = snd_oxfw_stream_start_simplex(oxfw, &oxfw->tx_stream, 0, 0);
  24
  25         mutex_unlock(&oxfw->mutex);
  26
  27         if (err < 0)
  28                 snd_oxfw_stream_lock_release(oxfw);
  29
  30         return err;
  31 }
  32
  33 static int midi_playback_open(struct snd_rawmidi_substream *substream)
  34 {
  35         struct snd_oxfw *oxfw = substream->rmidi->private_data;
  36         int err;
  37
  38         err = snd_oxfw_stream_lock_try(oxfw);
  39         if (err < 0)
  40                 return err;
  41
  42         mutex_lock(&oxfw->mutex);
  43
  44         oxfw->playback_substreams++;
  45         err = snd_oxfw_stream_start_simplex(oxfw, &oxfw->rx_stream, 0, 0);
  46
  47         mutex_unlock(&oxfw->mutex);
  48
  49         if (err < 0)
  50                 snd_oxfw_stream_lock_release(oxfw);
  51
  52         return err;
  53 }
  54
  55 static int midi_capture_close(struct snd_rawmidi_substream *substream)
  56 {
  57         struct snd_oxfw *oxfw = substream->rmidi->private_data;
  58
  59         mutex_lock(&oxfw->mutex);
  60
  61         oxfw->capture_substreams--;
  62         snd_oxfw_stream_stop_simplex(oxfw, &oxfw->tx_stream);
  63
  64         mutex_unlock(&oxfw->mutex);
  65
  66         snd_oxfw_stream_lock_release(oxfw);
  67         return 0;
  68 }
  69
  70 static int midi_playback_close(struct snd_rawmidi_substream *substream)
  71 {
  72         struct snd_oxfw *oxfw = substream->rmidi->private_data;
  73
  74         mutex_lock(&oxfw->mutex);
  75
  76         oxfw->playback_substreams--;
  77         snd_oxfw_stream_stop_simplex(oxfw, &oxfw->rx_stream);
  78
  79         mutex_unlock(&oxfw->mutex);
  80
  81         snd_oxfw_stream_lock_release(oxfw);
  82         return 0;
  83 }
  84
  85 static void midi_capture_trigger(struct snd_rawmidi_substream *substrm, int up)
  86 {
  87         struct snd_oxfw *oxfw = substrm->rmidi->private_data;
  88         unsigned long flags;
  89
  90         spin_lock_irqsave(&oxfw->lock, flags);
  91
  92         if (up)
  93                 amdtp_am824_midi_trigger(&oxfw->tx_stream,
  94                                          substrm->number, substrm);
  95         else
  96                 amdtp_am824_midi_trigger(&oxfw->tx_stream,
  97                                          substrm->number, NULL);
  98
  99         spin_unlock_irqrestore(&oxfw->lock, flags);
 100 }
 101
 102 static void midi_playback_trigger(struct snd_rawmidi_substream *substrm, int up)
 103 {
 104         struct snd_oxfw *oxfw = substrm->rmidi->private_data;
 105         unsigned long flags;
 106
 107         spin_lock_irqsave(&oxfw->lock, flags);
 108
 109         if (up)
 110                 amdtp_am824_midi_trigger(&oxfw->rx_stream,
 111                                          substrm->number, substrm);
 112         else
 113                 amdtp_am824_midi_trigger(&oxfw->rx_stream,
 114                                          substrm->number, NULL);
 115
 116         spin_unlock_irqrestore(&oxfw->lock, flags);
 117 }
 118
 119 static struct snd_rawmidi_ops midi_capture_ops = {
 120         .open           = midi_capture_open,
 121         .close          = midi_capture_close,
 122         .trigger        = midi_capture_trigger,
 123 };
 124
 125 static struct snd_rawmidi_ops midi_playback_ops = {
 126         .open           = midi_playback_open,
 127         .close          = midi_playback_close,
 128         .trigger        = midi_playback_trigger,
 129 };
 130
 131 static void set_midi_substream_names(struct snd_oxfw *oxfw,
 132                                      struct snd_rawmidi_str *str)
 133 {
 134         struct snd_rawmidi_substream *subs;
 135
 136         list_for_each_entry(subs, &str->substreams, list) {
 137                 snprintf(subs->name, sizeof(subs->name),
 138                          "%s MIDI %d",
 139                          oxfw->card->shortname, subs->number + 1);
 140         }
 141 }
 142
 143 int snd_oxfw_create_midi(struct snd_oxfw *oxfw)
 144 {
 145         struct snd_oxfw_stream_formation formation;
 146         struct snd_rawmidi *rmidi;
 147         struct snd_rawmidi_str *str;
 148         u8 *format;
 149         int i, err;
 150
 151         /* If its stream has MIDI conformant data channel, add one MIDI port */
 152         for (i = 0; i < SND_OXFW_STREAM_FORMAT_ENTRIES; i++) {
 153                 format = oxfw->tx_stream_formats[i];
 154                 if (format != NULL) {
 155                         err = snd_oxfw_stream_parse_format(format, &formation);
 156                         if (err >= 0 && formation.midi > 0)
 157                                 oxfw->midi_input_ports = 1;
 158                 }
 159
 160                 format = oxfw->rx_stream_formats[i];
 161                 if (format != NULL) {
 162                         err = snd_oxfw_stream_parse_format(format, &formation);
 163                         if (err >= 0 && formation.midi > 0)
 164                                 oxfw->midi_output_ports = 1;
 165                 }
 166         }
 167         if ((oxfw->midi_input_ports == 0) && (oxfw->midi_output_ports == 0))
 168                 return 0;
 169
 170         /* create midi ports */
 171         err = snd_rawmidi_new(oxfw->card, oxfw->card->driver, 0,
 172                               oxfw->midi_output_ports, oxfw->midi_input_ports,
 173                               &rmidi);
 174         if (err < 0)
 175                 return err;
 176
 177         snprintf(rmidi->name, sizeof(rmidi->name),
 178                  "%s MIDI", oxfw->card->shortname);
 179         rmidi->private_data = oxfw;
 180
 181         if (oxfw->midi_input_ports > 0) {
 182                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_INPUT;
 183
 184                 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT,
 185                                     &midi_capture_ops);
 186
 187                 str = &rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT];
 188
 189                 set_midi_substream_names(oxfw, str);
 190         }
 191
 192         if (oxfw->midi_output_ports > 0) {
 193                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT;
 194
 195                 snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT,
 196                                     &midi_playback_ops);
 197
 198                 str = &rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT];
 199
 200                 set_midi_substream_names(oxfw, str);
 201         }
 202
 203         if ((oxfw->midi_output_ports > 0) && (oxfw->midi_input_ports > 0))
 204                 rmidi->info_flags |= SNDRV_RAWMIDI_INFO_DUPLEX;
 205
 206         return 0;
 207 }