~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/core/seq/seq_virmidi.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  Virtual Raw MIDI client on Sequencer
  3  *
  4  *  Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>,
  5  *                        Jaroslav Kysela <perex@perex.cz>
  6  *
  7  *   This program is free software; you can redistribute it and/or modify
  8  *   it under the terms of the GNU General Public License as published by
  9  *   the Free Software Foundation; either version 2 of the License, or
 10  *   (at your option) any later version.
 11  *
 12  *   This program is distributed in the hope that it will be useful,
 13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 15  *   GNU General Public License for more details.
 16  *
 17  *   You should have received a copy of the GNU General Public License
 18  *   along with this program; if not, write to the Free Software
 19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 20  *
 21  */
 22 
 23 /*
 24  * Virtual Raw MIDI client
 25  *
 26  * The virtual rawmidi client is a sequencer client which associate
 27  * a rawmidi device file.  The created rawmidi device file can be
 28  * accessed as a normal raw midi, but its MIDI source and destination
 29  * are arbitrary.  For example, a user-client software synth connected
 30  * to this port can be used as a normal midi device as well.
 31  *
 32  * The virtual rawmidi device accepts also multiple opens.  Each file
 33  * has its own input buffer, so that no conflict would occur.  The drain
 34  * of input/output buffer acts only to the local buffer.
 35  *
 36  */
 37 
 38 #include <linux/init.h>
 39 #include <linux/wait.h>
 40 #include <linux/module.h>
 41 #include <linux/slab.h>
 42 #include <sound/core.h>
 43 #include <sound/rawmidi.h>
 44 #include <sound/info.h>
 45 #include <sound/control.h>
 46 #include <sound/minors.h>
 47 #include <sound/seq_kernel.h>
 48 #include <sound/seq_midi_event.h>
 49 #include <sound/seq_virmidi.h>
 50 
 51 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
 52 MODULE_DESCRIPTION("Virtual Raw MIDI client on Sequencer");
 53 MODULE_LICENSE("GPL");
 54 
 55 /*
 56  * initialize an event record
 57  */
 58 static void snd_virmidi_init_event(struct snd_virmidi *vmidi,
 59                                    struct snd_seq_event *ev)
 60 {
 61         memset(ev, 0, sizeof(*ev));
 62         ev->source.port = vmidi->port;
 63         switch (vmidi->seq_mode) {
 64         case SNDRV_VIRMIDI_SEQ_DISPATCH:
 65                 ev->dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
 66                 break;
 67         case SNDRV_VIRMIDI_SEQ_ATTACH:
 68                 /* FIXME: source and destination are same - not good.. */
 69                 ev->dest.client = vmidi->client;
 70                 ev->dest.port = vmidi->port;
 71                 break;
 72         }
 73         ev->type = SNDRV_SEQ_EVENT_NONE;
 74 }
 75 
 76 /*
 77  * decode input event and put to read buffer of each opened file
 78  */
 79 static int snd_virmidi_dev_receive_event(struct snd_virmidi_dev *rdev,
 80                                          struct snd_seq_event *ev,
 81                                          bool atomic)
 82 {
 83         struct snd_virmidi *vmidi;
 84         unsigned char msg[4];
 85         int len;
 86 
 87         if (atomic)
 88                 read_lock(&rdev->filelist_lock);
 89         else
 90                 down_read(&rdev->filelist_sem);
 91         list_for_each_entry(vmidi, &rdev->filelist, list) {
 92                 if (!READ_ONCE(vmidi->trigger))
 93                         continue;
 94                 if (ev->type == SNDRV_SEQ_EVENT_SYSEX) {
 95                         if ((ev->flags & SNDRV_SEQ_EVENT_LENGTH_MASK) != SNDRV_SEQ_EVENT_LENGTH_VARIABLE)
 96                                 continue;
 97                         snd_seq_dump_var_event(ev, (snd_seq_dump_func_t)snd_rawmidi_receive, vmidi->substream);
 98                 } else {
 99                         len = snd_midi_event_decode(vmidi->parser, msg, sizeof(msg), ev);
100                         if (len > 0)
101                                 snd_rawmidi_receive(vmidi->substream, msg, len);
102                 }
103         }
104         if (atomic)
105                 read_unlock(&rdev->filelist_lock);
106         else
107                 up_read(&rdev->filelist_sem);
108 
109         return 0;
110 }
111 
112 /*
113  * event handler of virmidi port
114  */
115 static int snd_virmidi_event_input(struct snd_seq_event *ev, int direct,
116                                    void *private_data, int atomic, int hop)
117 {
118         struct snd_virmidi_dev *rdev;
119 
120         rdev = private_data;
121         if (!(rdev->flags & SNDRV_VIRMIDI_USE))
122                 return 0; /* ignored */
123         return snd_virmidi_dev_receive_event(rdev, ev, atomic);
124 }
125 
126 /*
127  * trigger rawmidi stream for input
128  */
129 static void snd_virmidi_input_trigger(struct snd_rawmidi_substream *substream, int up)
130 {
131         struct snd_virmidi *vmidi = substream->runtime->private_data;
132 
133         WRITE_ONCE(vmidi->trigger, !!up);
134 }
135 
136 /* process rawmidi bytes and send events;
137  * we need no lock here for vmidi->event since it's handled only in this work
138  */
139 static void snd_vmidi_output_work(struct work_struct *work)
140 {
141         struct snd_virmidi *vmidi;
142         struct snd_rawmidi_substream *substream;
143         unsigned char input;
144         int ret;
145 
146         vmidi = container_of(work, struct snd_virmidi, output_work);
147         substream = vmidi->substream;
148 
149         /* discard the outputs in dispatch mode unless subscribed */
150         if (vmidi->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH &&
151             !(vmidi->rdev->flags & SNDRV_VIRMIDI_SUBSCRIBE)) {
152                 snd_rawmidi_proceed(substream);
153                 return;
154         }
155 
156         while (READ_ONCE(vmidi->trigger)) {
157                 if (snd_rawmidi_transmit(substream, &input, 1) != 1)
158                         break;
159                 if (!snd_midi_event_encode_byte(vmidi->parser, input,
160                                                 &vmidi->event))
161                         continue;
162                 if (vmidi->event.type != SNDRV_SEQ_EVENT_NONE) {
163                         ret = snd_seq_kernel_client_dispatch(vmidi->client,
164                                                              &vmidi->event,
165                                                              false, 0);
166                         vmidi->event.type = SNDRV_SEQ_EVENT_NONE;
167                         if (ret < 0)
168                                 break;
169                 }
170                 /* rawmidi input might be huge, allow to have a break */
171                 cond_resched();
172         }
173 }
174 
175 /*
176  * trigger rawmidi stream for output
177  */
178 static void snd_virmidi_output_trigger(struct snd_rawmidi_substream *substream, int up)
179 {
180         struct snd_virmidi *vmidi = substream->runtime->private_data;
181 
182         WRITE_ONCE(vmidi->trigger, !!up);
183         if (up)
184                 queue_work(system_highpri_wq, &vmidi->output_work);
185 }
186 
187 /*
188  * open rawmidi handle for input
189  */
190 static int snd_virmidi_input_open(struct snd_rawmidi_substream *substream)
191 {
192         struct snd_virmidi_dev *rdev = substream->rmidi->private_data;
193         struct snd_rawmidi_runtime *runtime = substream->runtime;
194         struct snd_virmidi *vmidi;
195 
196         vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL);
197         if (vmidi == NULL)
198                 return -ENOMEM;
199         vmidi->substream = substream;
200         if (snd_midi_event_new(0, &vmidi->parser) < 0) {
201                 kfree(vmidi);
202                 return -ENOMEM;
203         }
204         vmidi->seq_mode = rdev->seq_mode;
205         vmidi->client = rdev->client;
206         vmidi->port = rdev->port;       
207         runtime->private_data = vmidi;
208         down_write(&rdev->filelist_sem);
209         write_lock_irq(&rdev->filelist_lock);
210         list_add_tail(&vmidi->list, &rdev->filelist);
211         write_unlock_irq(&rdev->filelist_lock);
212         up_write(&rdev->filelist_sem);
213         vmidi->rdev = rdev;
214         return 0;
215 }
216 
217 /*
218  * open rawmidi handle for output
219  */
220 static int snd_virmidi_output_open(struct snd_rawmidi_substream *substream)
221 {
222         struct snd_virmidi_dev *rdev = substream->rmidi->private_data;
223         struct snd_rawmidi_runtime *runtime = substream->runtime;
224         struct snd_virmidi *vmidi;
225 
226         vmidi = kzalloc(sizeof(*vmidi), GFP_KERNEL);
227         if (vmidi == NULL)
228                 return -ENOMEM;
229         vmidi->substream = substream;
230         if (snd_midi_event_new(MAX_MIDI_EVENT_BUF, &vmidi->parser) < 0) {
231                 kfree(vmidi);
232                 return -ENOMEM;
233         }
234         vmidi->seq_mode = rdev->seq_mode;
235         vmidi->client = rdev->client;
236         vmidi->port = rdev->port;
237         snd_virmidi_init_event(vmidi, &vmidi->event);
238         vmidi->rdev = rdev;
239         INIT_WORK(&vmidi->output_work, snd_vmidi_output_work);
240         runtime->private_data = vmidi;
241         return 0;
242 }
243 
244 /*
245  * close rawmidi handle for input
246  */
247 static int snd_virmidi_input_close(struct snd_rawmidi_substream *substream)
248 {
249         struct snd_virmidi_dev *rdev = substream->rmidi->private_data;
250         struct snd_virmidi *vmidi = substream->runtime->private_data;
251 
252         down_write(&rdev->filelist_sem);
253         write_lock_irq(&rdev->filelist_lock);
254         list_del(&vmidi->list);
255         write_unlock_irq(&rdev->filelist_lock);
256         up_write(&rdev->filelist_sem);
257         snd_midi_event_free(vmidi->parser);
258         substream->runtime->private_data = NULL;
259         kfree(vmidi);
260         return 0;
261 }
262 
263 /*
264  * close rawmidi handle for output
265  */
266 static int snd_virmidi_output_close(struct snd_rawmidi_substream *substream)
267 {
268         struct snd_virmidi *vmidi = substream->runtime->private_data;
269 
270         WRITE_ONCE(vmidi->trigger, false); /* to be sure */
271         cancel_work_sync(&vmidi->output_work);
272         snd_midi_event_free(vmidi->parser);
273         substream->runtime->private_data = NULL;
274         kfree(vmidi);
275         return 0;
276 }
277 
278 /*
279  * subscribe callback - allow output to rawmidi device
280  */
281 static int snd_virmidi_subscribe(void *private_data,
282                                  struct snd_seq_port_subscribe *info)
283 {
284         struct snd_virmidi_dev *rdev;
285 
286         rdev = private_data;
287         if (!try_module_get(rdev->card->module))
288                 return -EFAULT;
289         rdev->flags |= SNDRV_VIRMIDI_SUBSCRIBE;
290         return 0;
291 }
292 
293 /*
294  * unsubscribe callback - disallow output to rawmidi device
295  */
296 static int snd_virmidi_unsubscribe(void *private_data,
297                                    struct snd_seq_port_subscribe *info)
298 {
299         struct snd_virmidi_dev *rdev;
300 
301         rdev = private_data;
302         rdev->flags &= ~SNDRV_VIRMIDI_SUBSCRIBE;
303         module_put(rdev->card->module);
304         return 0;
305 }
306 
307 
308 /*
309  * use callback - allow input to rawmidi device
310  */
311 static int snd_virmidi_use(void *private_data,
312                            struct snd_seq_port_subscribe *info)
313 {
314         struct snd_virmidi_dev *rdev;
315 
316         rdev = private_data;
317         if (!try_module_get(rdev->card->module))
318                 return -EFAULT;
319         rdev->flags |= SNDRV_VIRMIDI_USE;
320         return 0;
321 }
322 
323 /*
324  * unuse callback - disallow input to rawmidi device
325  */
326 static int snd_virmidi_unuse(void *private_data,
327                              struct snd_seq_port_subscribe *info)
328 {
329         struct snd_virmidi_dev *rdev;
330 
331         rdev = private_data;
332         rdev->flags &= ~SNDRV_VIRMIDI_USE;
333         module_put(rdev->card->module);
334         return 0;
335 }
336 
337 
338 /*
339  *  Register functions
340  */
341 
342 static const struct snd_rawmidi_ops snd_virmidi_input_ops = {
343         .open = snd_virmidi_input_open,
344         .close = snd_virmidi_input_close,
345         .trigger = snd_virmidi_input_trigger,
346 };
347 
348 static const struct snd_rawmidi_ops snd_virmidi_output_ops = {
349         .open = snd_virmidi_output_open,
350         .close = snd_virmidi_output_close,
351         .trigger = snd_virmidi_output_trigger,
352 };
353 
354 /*
355  * create a sequencer client and a port
356  */
357 static int snd_virmidi_dev_attach_seq(struct snd_virmidi_dev *rdev)
358 {
359         int client;
360         struct snd_seq_port_callback pcallbacks;
361         struct snd_seq_port_info *pinfo;
362         int err;
363 
364         if (rdev->client >= 0)
365                 return 0;
366 
367         pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
368         if (!pinfo) {
369                 err = -ENOMEM;
370                 goto __error;
371         }
372 
373         client = snd_seq_create_kernel_client(rdev->card, rdev->device,
374                                               "%s %d-%d", rdev->rmidi->name,
375                                               rdev->card->number,
376                                               rdev->device);
377         if (client < 0) {
378                 err = client;
379                 goto __error;
380         }
381         rdev->client = client;
382 
383         /* create a port */
384         pinfo->addr.client = client;
385         sprintf(pinfo->name, "VirMIDI %d-%d", rdev->card->number, rdev->device);
386         /* set all capabilities */
387         pinfo->capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SYNC_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
388         pinfo->capability |= SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SYNC_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ;
389         pinfo->capability |= SNDRV_SEQ_PORT_CAP_DUPLEX;
390         pinfo->type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
391                 | SNDRV_SEQ_PORT_TYPE_SOFTWARE
392                 | SNDRV_SEQ_PORT_TYPE_PORT;
393         pinfo->midi_channels = 16;
394         memset(&pcallbacks, 0, sizeof(pcallbacks));
395         pcallbacks.owner = THIS_MODULE;
396         pcallbacks.private_data = rdev;
397         pcallbacks.subscribe = snd_virmidi_subscribe;
398         pcallbacks.unsubscribe = snd_virmidi_unsubscribe;
399         pcallbacks.use = snd_virmidi_use;
400         pcallbacks.unuse = snd_virmidi_unuse;
401         pcallbacks.event_input = snd_virmidi_event_input;
402         pinfo->kernel = &pcallbacks;
403         err = snd_seq_kernel_client_ctl(client, SNDRV_SEQ_IOCTL_CREATE_PORT, pinfo);
404         if (err < 0) {
405                 snd_seq_delete_kernel_client(client);
406                 rdev->client = -1;
407                 goto __error;
408         }
409 
410         rdev->port = pinfo->addr.port;
411         err = 0; /* success */
412 
413  __error:
414         kfree(pinfo);
415         return err;
416 }
417 
418 
419 /*
420  * release the sequencer client
421  */
422 static void snd_virmidi_dev_detach_seq(struct snd_virmidi_dev *rdev)
423 {
424         if (rdev->client >= 0) {
425                 snd_seq_delete_kernel_client(rdev->client);
426                 rdev->client = -1;
427         }
428 }
429 
430 /*
431  * register the device
432  */
433 static int snd_virmidi_dev_register(struct snd_rawmidi *rmidi)
434 {
435         struct snd_virmidi_dev *rdev = rmidi->private_data;
436         int err;
437 
438         switch (rdev->seq_mode) {
439         case SNDRV_VIRMIDI_SEQ_DISPATCH:
440                 err = snd_virmidi_dev_attach_seq(rdev);
441                 if (err < 0)
442                         return err;
443                 break;
444         case SNDRV_VIRMIDI_SEQ_ATTACH:
445                 if (rdev->client == 0)
446                         return -EINVAL;
447                 /* should check presence of port more strictly.. */
448                 break;
449         default:
450                 pr_err("ALSA: seq_virmidi: seq_mode is not set: %d\n", rdev->seq_mode);
451                 return -EINVAL;
452         }
453         return 0;
454 }
455 
456 
457 /*
458  * unregister the device
459  */
460 static int snd_virmidi_dev_unregister(struct snd_rawmidi *rmidi)
461 {
462         struct snd_virmidi_dev *rdev = rmidi->private_data;
463 
464         if (rdev->seq_mode == SNDRV_VIRMIDI_SEQ_DISPATCH)
465                 snd_virmidi_dev_detach_seq(rdev);
466         return 0;
467 }
468 
469 /*
470  *
471  */
472 static const struct snd_rawmidi_global_ops snd_virmidi_global_ops = {
473         .dev_register = snd_virmidi_dev_register,
474         .dev_unregister = snd_virmidi_dev_unregister,
475 };
476 
477 /*
478  * free device
479  */
480 static void snd_virmidi_free(struct snd_rawmidi *rmidi)
481 {
482         struct snd_virmidi_dev *rdev = rmidi->private_data;
483         kfree(rdev);
484 }
485 
486 /*
487  * create a new device
488  *
489  */
490 /* exported */
491 int snd_virmidi_new(struct snd_card *card, int device, struct snd_rawmidi **rrmidi)
492 {
493         struct snd_rawmidi *rmidi;
494         struct snd_virmidi_dev *rdev;
495         int err;
496         
497         *rrmidi = NULL;
498         if ((err = snd_rawmidi_new(card, "VirMidi", device,
499                                    16,  /* may be configurable */
500                                    16,  /* may be configurable */
501                                    &rmidi)) < 0)
502                 return err;
503         strcpy(rmidi->name, rmidi->id);
504         rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
505         if (rdev == NULL) {
506                 snd_device_free(card, rmidi);
507                 return -ENOMEM;
508         }
509         rdev->card = card;
510         rdev->rmidi = rmidi;
511         rdev->device = device;
512         rdev->client = -1;
513         init_rwsem(&rdev->filelist_sem);
514         rwlock_init(&rdev->filelist_lock);
515         INIT_LIST_HEAD(&rdev->filelist);
516         rdev->seq_mode = SNDRV_VIRMIDI_SEQ_DISPATCH;
517         rmidi->private_data = rdev;
518         rmidi->private_free = snd_virmidi_free;
519         rmidi->ops = &snd_virmidi_global_ops;
520         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_virmidi_input_ops);
521         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_virmidi_output_ops);
522         rmidi->info_flags = SNDRV_RAWMIDI_INFO_INPUT |
523                             SNDRV_RAWMIDI_INFO_OUTPUT |
524                             SNDRV_RAWMIDI_INFO_DUPLEX;
525         *rrmidi = rmidi;
526         return 0;
527 }
528 EXPORT_SYMBOL(snd_virmidi_new);
529 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp