1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Abstract layer for MIDI v1.0 stream
4 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
7 #include <sound/core.h>
8 #include <linux/major.h>
9 #include <linux/init.h>
10 #include <linux/sched/signal.h>
11 #include <linux/slab.h>
12 #include <linux/time.h>
13 #include <linux/wait.h>
14 #include <linux/mutex.h>
15 #include <linux/module.h>
16 #include <linux/delay.h>
18 #include <linux/nospec.h>
19 #include <sound/rawmidi.h>
20 #include <sound/info.h>
21 #include <sound/control.h>
22 #include <sound/minors.h>
23 #include <sound/initval.h>
25 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
26 MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA.");
27 MODULE_LICENSE("GPL");
29 #ifdef CONFIG_SND_OSSEMUL
30 static int midi_map
[SNDRV_CARDS
];
31 static int amidi_map
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
-1)] = 1};
32 module_param_array(midi_map
, int, NULL
, 0444);
33 MODULE_PARM_DESC(midi_map
, "Raw MIDI device number assigned to 1st OSS device.");
34 module_param_array(amidi_map
, int, NULL
, 0444);
35 MODULE_PARM_DESC(amidi_map
, "Raw MIDI device number assigned to 2nd OSS device.");
36 #endif /* CONFIG_SND_OSSEMUL */
38 static int snd_rawmidi_free(struct snd_rawmidi
*rawmidi
);
39 static int snd_rawmidi_dev_free(struct snd_device
*device
);
40 static int snd_rawmidi_dev_register(struct snd_device
*device
);
41 static int snd_rawmidi_dev_disconnect(struct snd_device
*device
);
43 static LIST_HEAD(snd_rawmidi_devices
);
44 static DEFINE_MUTEX(register_mutex
);
46 #define rmidi_err(rmidi, fmt, args...) \
47 dev_err(&(rmidi)->dev, fmt, ##args)
48 #define rmidi_warn(rmidi, fmt, args...) \
49 dev_warn(&(rmidi)->dev, fmt, ##args)
50 #define rmidi_dbg(rmidi, fmt, args...) \
51 dev_dbg(&(rmidi)->dev, fmt, ##args)
53 struct snd_rawmidi_status32
{
55 s32 tstamp_sec
; /* Timestamp */
57 u32 avail
; /* available bytes */
58 u32 xruns
; /* count of overruns since last status (in bytes) */
59 unsigned char reserved
[16]; /* reserved for future use */
62 #define SNDRV_RAWMIDI_IOCTL_STATUS32 _IOWR('W', 0x20, struct snd_rawmidi_status32)
64 struct snd_rawmidi_status64
{
66 u8 rsvd
[4]; /* alignment */
67 s64 tstamp_sec
; /* Timestamp */
69 size_t avail
; /* available bytes */
70 size_t xruns
; /* count of overruns since last status (in bytes) */
71 unsigned char reserved
[16]; /* reserved for future use */
74 #define SNDRV_RAWMIDI_IOCTL_STATUS64 _IOWR('W', 0x20, struct snd_rawmidi_status64)
76 static struct snd_rawmidi
*snd_rawmidi_search(struct snd_card
*card
, int device
)
78 struct snd_rawmidi
*rawmidi
;
80 list_for_each_entry(rawmidi
, &snd_rawmidi_devices
, list
)
81 if (rawmidi
->card
== card
&& rawmidi
->device
== device
)
86 static inline unsigned short snd_rawmidi_file_flags(struct file
*file
)
88 switch (file
->f_mode
& (FMODE_READ
| FMODE_WRITE
)) {
90 return SNDRV_RAWMIDI_LFLG_OUTPUT
;
92 return SNDRV_RAWMIDI_LFLG_INPUT
;
94 return SNDRV_RAWMIDI_LFLG_OPEN
;
98 static inline int snd_rawmidi_ready(struct snd_rawmidi_substream
*substream
)
100 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
102 return runtime
->avail
>= runtime
->avail_min
;
105 static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream
*substream
,
108 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
110 return runtime
->avail
>= runtime
->avail_min
&&
111 (!substream
->append
|| runtime
->avail
>= count
);
114 static void snd_rawmidi_input_event_work(struct work_struct
*work
)
116 struct snd_rawmidi_runtime
*runtime
=
117 container_of(work
, struct snd_rawmidi_runtime
, event_work
);
120 runtime
->event(runtime
->substream
);
123 /* buffer refcount management: call with runtime->lock held */
124 static inline void snd_rawmidi_buffer_ref(struct snd_rawmidi_runtime
*runtime
)
126 runtime
->buffer_ref
++;
129 static inline void snd_rawmidi_buffer_unref(struct snd_rawmidi_runtime
*runtime
)
131 runtime
->buffer_ref
--;
134 static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream
*substream
)
136 struct snd_rawmidi_runtime
*runtime
;
138 runtime
= kzalloc(sizeof(*runtime
), GFP_KERNEL
);
141 runtime
->substream
= substream
;
142 spin_lock_init(&runtime
->lock
);
143 init_waitqueue_head(&runtime
->sleep
);
144 INIT_WORK(&runtime
->event_work
, snd_rawmidi_input_event_work
);
145 runtime
->event
= NULL
;
146 runtime
->buffer_size
= PAGE_SIZE
;
147 runtime
->avail_min
= 1;
148 if (substream
->stream
== SNDRV_RAWMIDI_STREAM_INPUT
)
151 runtime
->avail
= runtime
->buffer_size
;
152 runtime
->buffer
= kvzalloc(runtime
->buffer_size
, GFP_KERNEL
);
153 if (!runtime
->buffer
) {
157 runtime
->appl_ptr
= runtime
->hw_ptr
= 0;
158 substream
->runtime
= runtime
;
162 static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream
*substream
)
164 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
166 kvfree(runtime
->buffer
);
168 substream
->runtime
= NULL
;
172 static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream
*substream
, int up
)
174 if (!substream
->opened
)
176 substream
->ops
->trigger(substream
, up
);
179 static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream
*substream
, int up
)
181 if (!substream
->opened
)
183 substream
->ops
->trigger(substream
, up
);
185 cancel_work_sync(&substream
->runtime
->event_work
);
188 static void __reset_runtime_ptrs(struct snd_rawmidi_runtime
*runtime
,
192 runtime
->appl_ptr
= runtime
->hw_ptr
= 0;
193 runtime
->avail
= is_input
? 0 : runtime
->buffer_size
;
196 static void reset_runtime_ptrs(struct snd_rawmidi_runtime
*runtime
,
201 spin_lock_irqsave(&runtime
->lock
, flags
);
202 __reset_runtime_ptrs(runtime
, is_input
);
203 spin_unlock_irqrestore(&runtime
->lock
, flags
);
206 int snd_rawmidi_drop_output(struct snd_rawmidi_substream
*substream
)
208 snd_rawmidi_output_trigger(substream
, 0);
209 reset_runtime_ptrs(substream
->runtime
, false);
212 EXPORT_SYMBOL(snd_rawmidi_drop_output
);
214 int snd_rawmidi_drain_output(struct snd_rawmidi_substream
*substream
)
218 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
222 timeout
= wait_event_interruptible_timeout(runtime
->sleep
,
223 (runtime
->avail
>= runtime
->buffer_size
),
225 if (signal_pending(current
))
227 if (runtime
->avail
< runtime
->buffer_size
&& !timeout
) {
228 rmidi_warn(substream
->rmidi
,
229 "rawmidi drain error (avail = %li, buffer_size = %li)\n",
230 (long)runtime
->avail
, (long)runtime
->buffer_size
);
234 if (err
!= -ERESTARTSYS
) {
235 /* we need wait a while to make sure that Tx FIFOs are empty */
236 if (substream
->ops
->drain
)
237 substream
->ops
->drain(substream
);
240 snd_rawmidi_drop_output(substream
);
244 EXPORT_SYMBOL(snd_rawmidi_drain_output
);
246 int snd_rawmidi_drain_input(struct snd_rawmidi_substream
*substream
)
248 snd_rawmidi_input_trigger(substream
, 0);
249 reset_runtime_ptrs(substream
->runtime
, true);
252 EXPORT_SYMBOL(snd_rawmidi_drain_input
);
254 /* look for an available substream for the given stream direction;
255 * if a specific subdevice is given, try to assign it
257 static int assign_substream(struct snd_rawmidi
*rmidi
, int subdevice
,
258 int stream
, int mode
,
259 struct snd_rawmidi_substream
**sub_ret
)
261 struct snd_rawmidi_substream
*substream
;
262 struct snd_rawmidi_str
*s
= &rmidi
->streams
[stream
];
263 static const unsigned int info_flags
[2] = {
264 [SNDRV_RAWMIDI_STREAM_OUTPUT
] = SNDRV_RAWMIDI_INFO_OUTPUT
,
265 [SNDRV_RAWMIDI_STREAM_INPUT
] = SNDRV_RAWMIDI_INFO_INPUT
,
268 if (!(rmidi
->info_flags
& info_flags
[stream
]))
270 if (subdevice
>= 0 && subdevice
>= s
->substream_count
)
273 list_for_each_entry(substream
, &s
->substreams
, list
) {
274 if (substream
->opened
) {
275 if (stream
== SNDRV_RAWMIDI_STREAM_INPUT
||
276 !(mode
& SNDRV_RAWMIDI_LFLG_APPEND
) ||
280 if (subdevice
< 0 || subdevice
== substream
->number
) {
281 *sub_ret
= substream
;
288 /* open and do ref-counting for the given substream */
289 static int open_substream(struct snd_rawmidi
*rmidi
,
290 struct snd_rawmidi_substream
*substream
,
295 if (substream
->use_count
== 0) {
296 err
= snd_rawmidi_runtime_create(substream
);
299 err
= substream
->ops
->open(substream
);
301 snd_rawmidi_runtime_free(substream
);
304 substream
->opened
= 1;
305 substream
->active_sensing
= 0;
306 if (mode
& SNDRV_RAWMIDI_LFLG_APPEND
)
307 substream
->append
= 1;
308 substream
->pid
= get_pid(task_pid(current
));
309 rmidi
->streams
[substream
->stream
].substream_opened
++;
311 substream
->use_count
++;
315 static void close_substream(struct snd_rawmidi
*rmidi
,
316 struct snd_rawmidi_substream
*substream
,
319 static int rawmidi_open_priv(struct snd_rawmidi
*rmidi
, int subdevice
, int mode
,
320 struct snd_rawmidi_file
*rfile
)
322 struct snd_rawmidi_substream
*sinput
= NULL
, *soutput
= NULL
;
325 rfile
->input
= rfile
->output
= NULL
;
326 if (mode
& SNDRV_RAWMIDI_LFLG_INPUT
) {
327 err
= assign_substream(rmidi
, subdevice
,
328 SNDRV_RAWMIDI_STREAM_INPUT
,
333 if (mode
& SNDRV_RAWMIDI_LFLG_OUTPUT
) {
334 err
= assign_substream(rmidi
, subdevice
,
335 SNDRV_RAWMIDI_STREAM_OUTPUT
,
342 err
= open_substream(rmidi
, sinput
, mode
);
347 err
= open_substream(rmidi
, soutput
, mode
);
350 close_substream(rmidi
, sinput
, 0);
355 rfile
->rmidi
= rmidi
;
356 rfile
->input
= sinput
;
357 rfile
->output
= soutput
;
361 /* called from sound/core/seq/seq_midi.c */
362 int snd_rawmidi_kernel_open(struct snd_card
*card
, int device
, int subdevice
,
363 int mode
, struct snd_rawmidi_file
*rfile
)
365 struct snd_rawmidi
*rmidi
;
368 if (snd_BUG_ON(!rfile
))
371 mutex_lock(®ister_mutex
);
372 rmidi
= snd_rawmidi_search(card
, device
);
375 else if (!try_module_get(rmidi
->card
->module
))
377 mutex_unlock(®ister_mutex
);
381 mutex_lock(&rmidi
->open_mutex
);
382 err
= rawmidi_open_priv(rmidi
, subdevice
, mode
, rfile
);
383 mutex_unlock(&rmidi
->open_mutex
);
385 module_put(rmidi
->card
->module
);
388 EXPORT_SYMBOL(snd_rawmidi_kernel_open
);
390 static int snd_rawmidi_open(struct inode
*inode
, struct file
*file
)
392 int maj
= imajor(inode
);
393 struct snd_card
*card
;
395 unsigned short fflags
;
397 struct snd_rawmidi
*rmidi
;
398 struct snd_rawmidi_file
*rawmidi_file
= NULL
;
399 wait_queue_entry_t wait
;
401 if ((file
->f_flags
& O_APPEND
) && !(file
->f_flags
& O_NONBLOCK
))
402 return -EINVAL
; /* invalid combination */
404 err
= stream_open(inode
, file
);
408 if (maj
== snd_major
) {
409 rmidi
= snd_lookup_minor_data(iminor(inode
),
410 SNDRV_DEVICE_TYPE_RAWMIDI
);
411 #ifdef CONFIG_SND_OSSEMUL
412 } else if (maj
== SOUND_MAJOR
) {
413 rmidi
= snd_lookup_oss_minor_data(iminor(inode
),
414 SNDRV_OSS_DEVICE_TYPE_MIDI
);
422 if (!try_module_get(rmidi
->card
->module
)) {
423 snd_card_unref(rmidi
->card
);
427 mutex_lock(&rmidi
->open_mutex
);
429 err
= snd_card_file_add(card
, file
);
432 fflags
= snd_rawmidi_file_flags(file
);
433 if ((file
->f_flags
& O_APPEND
) || maj
== SOUND_MAJOR
) /* OSS emul? */
434 fflags
|= SNDRV_RAWMIDI_LFLG_APPEND
;
435 rawmidi_file
= kmalloc(sizeof(*rawmidi_file
), GFP_KERNEL
);
436 if (rawmidi_file
== NULL
) {
440 init_waitqueue_entry(&wait
, current
);
441 add_wait_queue(&rmidi
->open_wait
, &wait
);
443 subdevice
= snd_ctl_get_preferred_subdevice(card
, SND_CTL_SUBDEV_RAWMIDI
);
444 err
= rawmidi_open_priv(rmidi
, subdevice
, fflags
, rawmidi_file
);
447 if (err
== -EAGAIN
) {
448 if (file
->f_flags
& O_NONBLOCK
) {
454 set_current_state(TASK_INTERRUPTIBLE
);
455 mutex_unlock(&rmidi
->open_mutex
);
457 mutex_lock(&rmidi
->open_mutex
);
458 if (rmidi
->card
->shutdown
) {
462 if (signal_pending(current
)) {
467 remove_wait_queue(&rmidi
->open_wait
, &wait
);
472 #ifdef CONFIG_SND_OSSEMUL
473 if (rawmidi_file
->input
&& rawmidi_file
->input
->runtime
)
474 rawmidi_file
->input
->runtime
->oss
= (maj
== SOUND_MAJOR
);
475 if (rawmidi_file
->output
&& rawmidi_file
->output
->runtime
)
476 rawmidi_file
->output
->runtime
->oss
= (maj
== SOUND_MAJOR
);
478 file
->private_data
= rawmidi_file
;
479 mutex_unlock(&rmidi
->open_mutex
);
480 snd_card_unref(rmidi
->card
);
484 snd_card_file_remove(card
, file
);
486 mutex_unlock(&rmidi
->open_mutex
);
487 module_put(rmidi
->card
->module
);
488 snd_card_unref(rmidi
->card
);
492 static void close_substream(struct snd_rawmidi
*rmidi
,
493 struct snd_rawmidi_substream
*substream
,
496 if (--substream
->use_count
)
500 if (substream
->stream
== SNDRV_RAWMIDI_STREAM_INPUT
)
501 snd_rawmidi_input_trigger(substream
, 0);
503 if (substream
->active_sensing
) {
504 unsigned char buf
= 0xfe;
505 /* sending single active sensing message
506 * to shut the device up
508 snd_rawmidi_kernel_write(substream
, &buf
, 1);
510 if (snd_rawmidi_drain_output(substream
) == -ERESTARTSYS
)
511 snd_rawmidi_output_trigger(substream
, 0);
514 substream
->ops
->close(substream
);
515 if (substream
->runtime
->private_free
)
516 substream
->runtime
->private_free(substream
);
517 snd_rawmidi_runtime_free(substream
);
518 substream
->opened
= 0;
519 substream
->append
= 0;
520 put_pid(substream
->pid
);
521 substream
->pid
= NULL
;
522 rmidi
->streams
[substream
->stream
].substream_opened
--;
525 static void rawmidi_release_priv(struct snd_rawmidi_file
*rfile
)
527 struct snd_rawmidi
*rmidi
;
529 rmidi
= rfile
->rmidi
;
530 mutex_lock(&rmidi
->open_mutex
);
532 close_substream(rmidi
, rfile
->input
, 1);
536 close_substream(rmidi
, rfile
->output
, 1);
537 rfile
->output
= NULL
;
540 mutex_unlock(&rmidi
->open_mutex
);
541 wake_up(&rmidi
->open_wait
);
544 /* called from sound/core/seq/seq_midi.c */
545 int snd_rawmidi_kernel_release(struct snd_rawmidi_file
*rfile
)
547 struct snd_rawmidi
*rmidi
;
549 if (snd_BUG_ON(!rfile
))
552 rmidi
= rfile
->rmidi
;
553 rawmidi_release_priv(rfile
);
554 module_put(rmidi
->card
->module
);
557 EXPORT_SYMBOL(snd_rawmidi_kernel_release
);
559 static int snd_rawmidi_release(struct inode
*inode
, struct file
*file
)
561 struct snd_rawmidi_file
*rfile
;
562 struct snd_rawmidi
*rmidi
;
563 struct module
*module
;
565 rfile
= file
->private_data
;
566 rmidi
= rfile
->rmidi
;
567 rawmidi_release_priv(rfile
);
569 module
= rmidi
->card
->module
;
570 snd_card_file_remove(rmidi
->card
, file
);
575 static int snd_rawmidi_info(struct snd_rawmidi_substream
*substream
,
576 struct snd_rawmidi_info
*info
)
578 struct snd_rawmidi
*rmidi
;
580 if (substream
== NULL
)
582 rmidi
= substream
->rmidi
;
583 memset(info
, 0, sizeof(*info
));
584 info
->card
= rmidi
->card
->number
;
585 info
->device
= rmidi
->device
;
586 info
->subdevice
= substream
->number
;
587 info
->stream
= substream
->stream
;
588 info
->flags
= rmidi
->info_flags
;
589 strcpy(info
->id
, rmidi
->id
);
590 strcpy(info
->name
, rmidi
->name
);
591 strcpy(info
->subname
, substream
->name
);
592 info
->subdevices_count
= substream
->pstr
->substream_count
;
593 info
->subdevices_avail
= (substream
->pstr
->substream_count
-
594 substream
->pstr
->substream_opened
);
598 static int snd_rawmidi_info_user(struct snd_rawmidi_substream
*substream
,
599 struct snd_rawmidi_info __user
*_info
)
601 struct snd_rawmidi_info info
;
604 err
= snd_rawmidi_info(substream
, &info
);
607 if (copy_to_user(_info
, &info
, sizeof(struct snd_rawmidi_info
)))
612 static int __snd_rawmidi_info_select(struct snd_card
*card
,
613 struct snd_rawmidi_info
*info
)
615 struct snd_rawmidi
*rmidi
;
616 struct snd_rawmidi_str
*pstr
;
617 struct snd_rawmidi_substream
*substream
;
619 rmidi
= snd_rawmidi_search(card
, info
->device
);
622 if (info
->stream
< 0 || info
->stream
> 1)
624 info
->stream
= array_index_nospec(info
->stream
, 2);
625 pstr
= &rmidi
->streams
[info
->stream
];
626 if (pstr
->substream_count
== 0)
628 if (info
->subdevice
>= pstr
->substream_count
)
630 list_for_each_entry(substream
, &pstr
->substreams
, list
) {
631 if ((unsigned int)substream
->number
== info
->subdevice
)
632 return snd_rawmidi_info(substream
, info
);
637 int snd_rawmidi_info_select(struct snd_card
*card
, struct snd_rawmidi_info
*info
)
641 mutex_lock(®ister_mutex
);
642 ret
= __snd_rawmidi_info_select(card
, info
);
643 mutex_unlock(®ister_mutex
);
646 EXPORT_SYMBOL(snd_rawmidi_info_select
);
648 static int snd_rawmidi_info_select_user(struct snd_card
*card
,
649 struct snd_rawmidi_info __user
*_info
)
652 struct snd_rawmidi_info info
;
654 if (get_user(info
.device
, &_info
->device
))
656 if (get_user(info
.stream
, &_info
->stream
))
658 if (get_user(info
.subdevice
, &_info
->subdevice
))
660 err
= snd_rawmidi_info_select(card
, &info
);
663 if (copy_to_user(_info
, &info
, sizeof(struct snd_rawmidi_info
)))
668 static int resize_runtime_buffer(struct snd_rawmidi_runtime
*runtime
,
669 struct snd_rawmidi_params
*params
,
672 char *newbuf
, *oldbuf
;
674 if (params
->buffer_size
< 32 || params
->buffer_size
> 1024L * 1024L)
676 if (params
->avail_min
< 1 || params
->avail_min
> params
->buffer_size
)
678 if (params
->buffer_size
!= runtime
->buffer_size
) {
679 newbuf
= kvzalloc(params
->buffer_size
, GFP_KERNEL
);
682 spin_lock_irq(&runtime
->lock
);
683 if (runtime
->buffer_ref
) {
684 spin_unlock_irq(&runtime
->lock
);
688 oldbuf
= runtime
->buffer
;
689 runtime
->buffer
= newbuf
;
690 runtime
->buffer_size
= params
->buffer_size
;
691 __reset_runtime_ptrs(runtime
, is_input
);
692 spin_unlock_irq(&runtime
->lock
);
695 runtime
->avail_min
= params
->avail_min
;
699 int snd_rawmidi_output_params(struct snd_rawmidi_substream
*substream
,
700 struct snd_rawmidi_params
*params
)
702 if (substream
->append
&& substream
->use_count
> 1)
704 snd_rawmidi_drain_output(substream
);
705 substream
->active_sensing
= !params
->no_active_sensing
;
706 return resize_runtime_buffer(substream
->runtime
, params
, false);
708 EXPORT_SYMBOL(snd_rawmidi_output_params
);
710 int snd_rawmidi_input_params(struct snd_rawmidi_substream
*substream
,
711 struct snd_rawmidi_params
*params
)
713 snd_rawmidi_drain_input(substream
);
714 return resize_runtime_buffer(substream
->runtime
, params
, true);
716 EXPORT_SYMBOL(snd_rawmidi_input_params
);
718 static int snd_rawmidi_output_status(struct snd_rawmidi_substream
*substream
,
719 struct snd_rawmidi_status64
*status
)
721 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
723 memset(status
, 0, sizeof(*status
));
724 status
->stream
= SNDRV_RAWMIDI_STREAM_OUTPUT
;
725 spin_lock_irq(&runtime
->lock
);
726 status
->avail
= runtime
->avail
;
727 spin_unlock_irq(&runtime
->lock
);
731 static int snd_rawmidi_input_status(struct snd_rawmidi_substream
*substream
,
732 struct snd_rawmidi_status64
*status
)
734 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
736 memset(status
, 0, sizeof(*status
));
737 status
->stream
= SNDRV_RAWMIDI_STREAM_INPUT
;
738 spin_lock_irq(&runtime
->lock
);
739 status
->avail
= runtime
->avail
;
740 status
->xruns
= runtime
->xruns
;
742 spin_unlock_irq(&runtime
->lock
);
746 static int snd_rawmidi_ioctl_status32(struct snd_rawmidi_file
*rfile
,
747 struct snd_rawmidi_status32 __user
*argp
)
750 struct snd_rawmidi_status32 __user
*status
= argp
;
751 struct snd_rawmidi_status32 status32
;
752 struct snd_rawmidi_status64 status64
;
754 if (copy_from_user(&status32
, argp
,
755 sizeof(struct snd_rawmidi_status32
)))
758 switch (status32
.stream
) {
759 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
760 if (rfile
->output
== NULL
)
762 err
= snd_rawmidi_output_status(rfile
->output
, &status64
);
764 case SNDRV_RAWMIDI_STREAM_INPUT
:
765 if (rfile
->input
== NULL
)
767 err
= snd_rawmidi_input_status(rfile
->input
, &status64
);
775 status32
= (struct snd_rawmidi_status32
) {
776 .stream
= status64
.stream
,
777 .tstamp_sec
= status64
.tstamp_sec
,
778 .tstamp_nsec
= status64
.tstamp_nsec
,
779 .avail
= status64
.avail
,
780 .xruns
= status64
.xruns
,
783 if (copy_to_user(status
, &status32
, sizeof(*status
)))
789 static int snd_rawmidi_ioctl_status64(struct snd_rawmidi_file
*rfile
,
790 struct snd_rawmidi_status64 __user
*argp
)
793 struct snd_rawmidi_status64 status
;
795 if (copy_from_user(&status
, argp
, sizeof(struct snd_rawmidi_status64
)))
798 switch (status
.stream
) {
799 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
800 if (rfile
->output
== NULL
)
802 err
= snd_rawmidi_output_status(rfile
->output
, &status
);
804 case SNDRV_RAWMIDI_STREAM_INPUT
:
805 if (rfile
->input
== NULL
)
807 err
= snd_rawmidi_input_status(rfile
->input
, &status
);
814 if (copy_to_user(argp
, &status
,
815 sizeof(struct snd_rawmidi_status64
)))
820 static long snd_rawmidi_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
822 struct snd_rawmidi_file
*rfile
;
823 void __user
*argp
= (void __user
*)arg
;
825 rfile
= file
->private_data
;
826 if (((cmd
>> 8) & 0xff) != 'W')
829 case SNDRV_RAWMIDI_IOCTL_PVERSION
:
830 return put_user(SNDRV_RAWMIDI_VERSION
, (int __user
*)argp
) ? -EFAULT
: 0;
831 case SNDRV_RAWMIDI_IOCTL_INFO
:
834 struct snd_rawmidi_info __user
*info
= argp
;
836 if (get_user(stream
, &info
->stream
))
839 case SNDRV_RAWMIDI_STREAM_INPUT
:
840 return snd_rawmidi_info_user(rfile
->input
, info
);
841 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
842 return snd_rawmidi_info_user(rfile
->output
, info
);
847 case SNDRV_RAWMIDI_IOCTL_PARAMS
:
849 struct snd_rawmidi_params params
;
851 if (copy_from_user(¶ms
, argp
, sizeof(struct snd_rawmidi_params
)))
853 switch (params
.stream
) {
854 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
855 if (rfile
->output
== NULL
)
857 return snd_rawmidi_output_params(rfile
->output
, ¶ms
);
858 case SNDRV_RAWMIDI_STREAM_INPUT
:
859 if (rfile
->input
== NULL
)
861 return snd_rawmidi_input_params(rfile
->input
, ¶ms
);
866 case SNDRV_RAWMIDI_IOCTL_STATUS32
:
867 return snd_rawmidi_ioctl_status32(rfile
, argp
);
868 case SNDRV_RAWMIDI_IOCTL_STATUS64
:
869 return snd_rawmidi_ioctl_status64(rfile
, argp
);
870 case SNDRV_RAWMIDI_IOCTL_DROP
:
874 if (get_user(val
, (int __user
*) argp
))
877 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
878 if (rfile
->output
== NULL
)
880 return snd_rawmidi_drop_output(rfile
->output
);
885 case SNDRV_RAWMIDI_IOCTL_DRAIN
:
889 if (get_user(val
, (int __user
*) argp
))
892 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
893 if (rfile
->output
== NULL
)
895 return snd_rawmidi_drain_output(rfile
->output
);
896 case SNDRV_RAWMIDI_STREAM_INPUT
:
897 if (rfile
->input
== NULL
)
899 return snd_rawmidi_drain_input(rfile
->input
);
905 rmidi_dbg(rfile
->rmidi
,
906 "rawmidi: unknown command = 0x%x\n", cmd
);
911 static int snd_rawmidi_control_ioctl(struct snd_card
*card
,
912 struct snd_ctl_file
*control
,
916 void __user
*argp
= (void __user
*)arg
;
919 case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE
:
923 if (get_user(device
, (int __user
*)argp
))
925 if (device
>= SNDRV_RAWMIDI_DEVICES
) /* next device is -1 */
926 device
= SNDRV_RAWMIDI_DEVICES
- 1;
927 mutex_lock(®ister_mutex
);
928 device
= device
< 0 ? 0 : device
+ 1;
929 while (device
< SNDRV_RAWMIDI_DEVICES
) {
930 if (snd_rawmidi_search(card
, device
))
934 if (device
== SNDRV_RAWMIDI_DEVICES
)
936 mutex_unlock(®ister_mutex
);
937 if (put_user(device
, (int __user
*)argp
))
941 case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE
:
945 if (get_user(val
, (int __user
*)argp
))
947 control
->preferred_subdevice
[SND_CTL_SUBDEV_RAWMIDI
] = val
;
950 case SNDRV_CTL_IOCTL_RAWMIDI_INFO
:
951 return snd_rawmidi_info_select_user(card
, argp
);
957 * snd_rawmidi_receive - receive the input data from the device
958 * @substream: the rawmidi substream
959 * @buffer: the buffer pointer
960 * @count: the data size to read
962 * Reads the data from the internal buffer.
964 * Return: The size of read data, or a negative error code on failure.
966 int snd_rawmidi_receive(struct snd_rawmidi_substream
*substream
,
967 const unsigned char *buffer
, int count
)
970 int result
= 0, count1
;
971 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
973 if (!substream
->opened
)
975 if (runtime
->buffer
== NULL
) {
976 rmidi_dbg(substream
->rmidi
,
977 "snd_rawmidi_receive: input is not active!!!\n");
980 spin_lock_irqsave(&runtime
->lock
, flags
);
981 if (count
== 1) { /* special case, faster code */
983 if (runtime
->avail
< runtime
->buffer_size
) {
984 runtime
->buffer
[runtime
->hw_ptr
++] = buffer
[0];
985 runtime
->hw_ptr
%= runtime
->buffer_size
;
992 substream
->bytes
+= count
;
993 count1
= runtime
->buffer_size
- runtime
->hw_ptr
;
996 if (count1
> (int)(runtime
->buffer_size
- runtime
->avail
))
997 count1
= runtime
->buffer_size
- runtime
->avail
;
998 memcpy(runtime
->buffer
+ runtime
->hw_ptr
, buffer
, count1
);
999 runtime
->hw_ptr
+= count1
;
1000 runtime
->hw_ptr
%= runtime
->buffer_size
;
1001 runtime
->avail
+= count1
;
1007 if (count1
> (int)(runtime
->buffer_size
- runtime
->avail
)) {
1008 count1
= runtime
->buffer_size
- runtime
->avail
;
1009 runtime
->xruns
+= count
- count1
;
1012 memcpy(runtime
->buffer
, buffer
, count1
);
1013 runtime
->hw_ptr
= count1
;
1014 runtime
->avail
+= count1
;
1021 schedule_work(&runtime
->event_work
);
1022 else if (snd_rawmidi_ready(substream
))
1023 wake_up(&runtime
->sleep
);
1025 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1028 EXPORT_SYMBOL(snd_rawmidi_receive
);
1030 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream
*substream
,
1031 unsigned char __user
*userbuf
,
1032 unsigned char *kernelbuf
, long count
)
1034 unsigned long flags
;
1035 long result
= 0, count1
;
1036 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1037 unsigned long appl_ptr
;
1040 spin_lock_irqsave(&runtime
->lock
, flags
);
1041 snd_rawmidi_buffer_ref(runtime
);
1042 while (count
> 0 && runtime
->avail
) {
1043 count1
= runtime
->buffer_size
- runtime
->appl_ptr
;
1046 if (count1
> (int)runtime
->avail
)
1047 count1
= runtime
->avail
;
1049 /* update runtime->appl_ptr before unlocking for userbuf */
1050 appl_ptr
= runtime
->appl_ptr
;
1051 runtime
->appl_ptr
+= count1
;
1052 runtime
->appl_ptr
%= runtime
->buffer_size
;
1053 runtime
->avail
-= count1
;
1056 memcpy(kernelbuf
+ result
, runtime
->buffer
+ appl_ptr
, count1
);
1058 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1059 if (copy_to_user(userbuf
+ result
,
1060 runtime
->buffer
+ appl_ptr
, count1
))
1062 spin_lock_irqsave(&runtime
->lock
, flags
);
1070 snd_rawmidi_buffer_unref(runtime
);
1071 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1072 return result
> 0 ? result
: err
;
1075 long snd_rawmidi_kernel_read(struct snd_rawmidi_substream
*substream
,
1076 unsigned char *buf
, long count
)
1078 snd_rawmidi_input_trigger(substream
, 1);
1079 return snd_rawmidi_kernel_read1(substream
, NULL
/*userbuf*/, buf
, count
);
1081 EXPORT_SYMBOL(snd_rawmidi_kernel_read
);
1083 static ssize_t
snd_rawmidi_read(struct file
*file
, char __user
*buf
, size_t count
,
1088 struct snd_rawmidi_file
*rfile
;
1089 struct snd_rawmidi_substream
*substream
;
1090 struct snd_rawmidi_runtime
*runtime
;
1092 rfile
= file
->private_data
;
1093 substream
= rfile
->input
;
1094 if (substream
== NULL
)
1096 runtime
= substream
->runtime
;
1097 snd_rawmidi_input_trigger(substream
, 1);
1100 spin_lock_irq(&runtime
->lock
);
1101 while (!snd_rawmidi_ready(substream
)) {
1102 wait_queue_entry_t wait
;
1104 if ((file
->f_flags
& O_NONBLOCK
) != 0 || result
> 0) {
1105 spin_unlock_irq(&runtime
->lock
);
1106 return result
> 0 ? result
: -EAGAIN
;
1108 init_waitqueue_entry(&wait
, current
);
1109 add_wait_queue(&runtime
->sleep
, &wait
);
1110 set_current_state(TASK_INTERRUPTIBLE
);
1111 spin_unlock_irq(&runtime
->lock
);
1113 remove_wait_queue(&runtime
->sleep
, &wait
);
1114 if (rfile
->rmidi
->card
->shutdown
)
1116 if (signal_pending(current
))
1117 return result
> 0 ? result
: -ERESTARTSYS
;
1118 if (!runtime
->avail
)
1119 return result
> 0 ? result
: -EIO
;
1120 spin_lock_irq(&runtime
->lock
);
1122 spin_unlock_irq(&runtime
->lock
);
1123 count1
= snd_rawmidi_kernel_read1(substream
,
1124 (unsigned char __user
*)buf
,
1128 return result
> 0 ? result
: count1
;
1137 * snd_rawmidi_transmit_empty - check whether the output buffer is empty
1138 * @substream: the rawmidi substream
1140 * Return: 1 if the internal output buffer is empty, 0 if not.
1142 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream
*substream
)
1144 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1146 unsigned long flags
;
1148 if (runtime
->buffer
== NULL
) {
1149 rmidi_dbg(substream
->rmidi
,
1150 "snd_rawmidi_transmit_empty: output is not active!!!\n");
1153 spin_lock_irqsave(&runtime
->lock
, flags
);
1154 result
= runtime
->avail
>= runtime
->buffer_size
;
1155 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1158 EXPORT_SYMBOL(snd_rawmidi_transmit_empty
);
1161 * __snd_rawmidi_transmit_peek - copy data from the internal buffer
1162 * @substream: the rawmidi substream
1163 * @buffer: the buffer pointer
1164 * @count: data size to transfer
1166 * This is a variant of snd_rawmidi_transmit_peek() without spinlock.
1168 int __snd_rawmidi_transmit_peek(struct snd_rawmidi_substream
*substream
,
1169 unsigned char *buffer
, int count
)
1172 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1174 if (runtime
->buffer
== NULL
) {
1175 rmidi_dbg(substream
->rmidi
,
1176 "snd_rawmidi_transmit_peek: output is not active!!!\n");
1180 if (runtime
->avail
>= runtime
->buffer_size
) {
1181 /* warning: lowlevel layer MUST trigger down the hardware */
1184 if (count
== 1) { /* special case, faster code */
1185 *buffer
= runtime
->buffer
[runtime
->hw_ptr
];
1188 count1
= runtime
->buffer_size
- runtime
->hw_ptr
;
1191 if (count1
> (int)(runtime
->buffer_size
- runtime
->avail
))
1192 count1
= runtime
->buffer_size
- runtime
->avail
;
1193 memcpy(buffer
, runtime
->buffer
+ runtime
->hw_ptr
, count1
);
1197 if (count
> (int)(runtime
->buffer_size
- runtime
->avail
- count1
))
1198 count
= runtime
->buffer_size
- runtime
->avail
- count1
;
1199 memcpy(buffer
+ count1
, runtime
->buffer
, count
);
1206 EXPORT_SYMBOL(__snd_rawmidi_transmit_peek
);
1209 * snd_rawmidi_transmit_peek - copy data from the internal buffer
1210 * @substream: the rawmidi substream
1211 * @buffer: the buffer pointer
1212 * @count: data size to transfer
1214 * Copies data from the internal output buffer to the given buffer.
1216 * Call this in the interrupt handler when the midi output is ready,
1217 * and call snd_rawmidi_transmit_ack() after the transmission is
1220 * Return: The size of copied data, or a negative error code on failure.
1222 int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream
*substream
,
1223 unsigned char *buffer
, int count
)
1225 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1227 unsigned long flags
;
1229 spin_lock_irqsave(&runtime
->lock
, flags
);
1230 result
= __snd_rawmidi_transmit_peek(substream
, buffer
, count
);
1231 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1234 EXPORT_SYMBOL(snd_rawmidi_transmit_peek
);
1237 * __snd_rawmidi_transmit_ack - acknowledge the transmission
1238 * @substream: the rawmidi substream
1239 * @count: the transferred count
1241 * This is a variant of __snd_rawmidi_transmit_ack() without spinlock.
1243 int __snd_rawmidi_transmit_ack(struct snd_rawmidi_substream
*substream
, int count
)
1245 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1247 if (runtime
->buffer
== NULL
) {
1248 rmidi_dbg(substream
->rmidi
,
1249 "snd_rawmidi_transmit_ack: output is not active!!!\n");
1252 snd_BUG_ON(runtime
->avail
+ count
> runtime
->buffer_size
);
1253 runtime
->hw_ptr
+= count
;
1254 runtime
->hw_ptr
%= runtime
->buffer_size
;
1255 runtime
->avail
+= count
;
1256 substream
->bytes
+= count
;
1258 if (runtime
->drain
|| snd_rawmidi_ready(substream
))
1259 wake_up(&runtime
->sleep
);
1263 EXPORT_SYMBOL(__snd_rawmidi_transmit_ack
);
1266 * snd_rawmidi_transmit_ack - acknowledge the transmission
1267 * @substream: the rawmidi substream
1268 * @count: the transferred count
1270 * Advances the hardware pointer for the internal output buffer with
1271 * the given size and updates the condition.
1272 * Call after the transmission is finished.
1274 * Return: The advanced size if successful, or a negative error code on failure.
1276 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream
*substream
, int count
)
1278 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1280 unsigned long flags
;
1282 spin_lock_irqsave(&runtime
->lock
, flags
);
1283 result
= __snd_rawmidi_transmit_ack(substream
, count
);
1284 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1287 EXPORT_SYMBOL(snd_rawmidi_transmit_ack
);
1290 * snd_rawmidi_transmit - copy from the buffer to the device
1291 * @substream: the rawmidi substream
1292 * @buffer: the buffer pointer
1293 * @count: the data size to transfer
1295 * Copies data from the buffer to the device and advances the pointer.
1297 * Return: The copied size if successful, or a negative error code on failure.
1299 int snd_rawmidi_transmit(struct snd_rawmidi_substream
*substream
,
1300 unsigned char *buffer
, int count
)
1302 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1304 unsigned long flags
;
1306 spin_lock_irqsave(&runtime
->lock
, flags
);
1307 if (!substream
->opened
)
1310 count
= __snd_rawmidi_transmit_peek(substream
, buffer
, count
);
1314 result
= __snd_rawmidi_transmit_ack(substream
, count
);
1316 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1319 EXPORT_SYMBOL(snd_rawmidi_transmit
);
1322 * snd_rawmidi_proceed - Discard the all pending bytes and proceed
1323 * @substream: rawmidi substream
1325 * Return: the number of discarded bytes
1327 int snd_rawmidi_proceed(struct snd_rawmidi_substream
*substream
)
1329 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1330 unsigned long flags
;
1333 spin_lock_irqsave(&runtime
->lock
, flags
);
1334 if (runtime
->avail
< runtime
->buffer_size
) {
1335 count
= runtime
->buffer_size
- runtime
->avail
;
1336 __snd_rawmidi_transmit_ack(substream
, count
);
1338 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1341 EXPORT_SYMBOL(snd_rawmidi_proceed
);
1343 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream
*substream
,
1344 const unsigned char __user
*userbuf
,
1345 const unsigned char *kernelbuf
,
1348 unsigned long flags
;
1349 long count1
, result
;
1350 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1351 unsigned long appl_ptr
;
1353 if (!kernelbuf
&& !userbuf
)
1355 if (snd_BUG_ON(!runtime
->buffer
))
1359 spin_lock_irqsave(&runtime
->lock
, flags
);
1360 if (substream
->append
) {
1361 if ((long)runtime
->avail
< count
) {
1362 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1366 snd_rawmidi_buffer_ref(runtime
);
1367 while (count
> 0 && runtime
->avail
> 0) {
1368 count1
= runtime
->buffer_size
- runtime
->appl_ptr
;
1371 if (count1
> (long)runtime
->avail
)
1372 count1
= runtime
->avail
;
1374 /* update runtime->appl_ptr before unlocking for userbuf */
1375 appl_ptr
= runtime
->appl_ptr
;
1376 runtime
->appl_ptr
+= count1
;
1377 runtime
->appl_ptr
%= runtime
->buffer_size
;
1378 runtime
->avail
-= count1
;
1381 memcpy(runtime
->buffer
+ appl_ptr
,
1382 kernelbuf
+ result
, count1
);
1384 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1385 if (copy_from_user(runtime
->buffer
+ appl_ptr
,
1386 userbuf
+ result
, count1
)) {
1387 spin_lock_irqsave(&runtime
->lock
, flags
);
1388 result
= result
> 0 ? result
: -EFAULT
;
1391 spin_lock_irqsave(&runtime
->lock
, flags
);
1397 count1
= runtime
->avail
< runtime
->buffer_size
;
1398 snd_rawmidi_buffer_unref(runtime
);
1399 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1401 snd_rawmidi_output_trigger(substream
, 1);
1405 long snd_rawmidi_kernel_write(struct snd_rawmidi_substream
*substream
,
1406 const unsigned char *buf
, long count
)
1408 return snd_rawmidi_kernel_write1(substream
, NULL
, buf
, count
);
1410 EXPORT_SYMBOL(snd_rawmidi_kernel_write
);
1412 static ssize_t
snd_rawmidi_write(struct file
*file
, const char __user
*buf
,
1413 size_t count
, loff_t
*offset
)
1415 long result
, timeout
;
1417 struct snd_rawmidi_file
*rfile
;
1418 struct snd_rawmidi_runtime
*runtime
;
1419 struct snd_rawmidi_substream
*substream
;
1421 rfile
= file
->private_data
;
1422 substream
= rfile
->output
;
1423 runtime
= substream
->runtime
;
1424 /* we cannot put an atomic message to our buffer */
1425 if (substream
->append
&& count
> runtime
->buffer_size
)
1429 spin_lock_irq(&runtime
->lock
);
1430 while (!snd_rawmidi_ready_append(substream
, count
)) {
1431 wait_queue_entry_t wait
;
1433 if (file
->f_flags
& O_NONBLOCK
) {
1434 spin_unlock_irq(&runtime
->lock
);
1435 return result
> 0 ? result
: -EAGAIN
;
1437 init_waitqueue_entry(&wait
, current
);
1438 add_wait_queue(&runtime
->sleep
, &wait
);
1439 set_current_state(TASK_INTERRUPTIBLE
);
1440 spin_unlock_irq(&runtime
->lock
);
1441 timeout
= schedule_timeout(30 * HZ
);
1442 remove_wait_queue(&runtime
->sleep
, &wait
);
1443 if (rfile
->rmidi
->card
->shutdown
)
1445 if (signal_pending(current
))
1446 return result
> 0 ? result
: -ERESTARTSYS
;
1447 if (!runtime
->avail
&& !timeout
)
1448 return result
> 0 ? result
: -EIO
;
1449 spin_lock_irq(&runtime
->lock
);
1451 spin_unlock_irq(&runtime
->lock
);
1452 count1
= snd_rawmidi_kernel_write1(substream
, buf
, NULL
, count
);
1454 return result
> 0 ? result
: count1
;
1457 if ((size_t)count1
< count
&& (file
->f_flags
& O_NONBLOCK
))
1461 if (file
->f_flags
& O_DSYNC
) {
1462 spin_lock_irq(&runtime
->lock
);
1463 while (runtime
->avail
!= runtime
->buffer_size
) {
1464 wait_queue_entry_t wait
;
1465 unsigned int last_avail
= runtime
->avail
;
1467 init_waitqueue_entry(&wait
, current
);
1468 add_wait_queue(&runtime
->sleep
, &wait
);
1469 set_current_state(TASK_INTERRUPTIBLE
);
1470 spin_unlock_irq(&runtime
->lock
);
1471 timeout
= schedule_timeout(30 * HZ
);
1472 remove_wait_queue(&runtime
->sleep
, &wait
);
1473 if (signal_pending(current
))
1474 return result
> 0 ? result
: -ERESTARTSYS
;
1475 if (runtime
->avail
== last_avail
&& !timeout
)
1476 return result
> 0 ? result
: -EIO
;
1477 spin_lock_irq(&runtime
->lock
);
1479 spin_unlock_irq(&runtime
->lock
);
1484 static __poll_t
snd_rawmidi_poll(struct file
*file
, poll_table
*wait
)
1486 struct snd_rawmidi_file
*rfile
;
1487 struct snd_rawmidi_runtime
*runtime
;
1490 rfile
= file
->private_data
;
1491 if (rfile
->input
!= NULL
) {
1492 runtime
= rfile
->input
->runtime
;
1493 snd_rawmidi_input_trigger(rfile
->input
, 1);
1494 poll_wait(file
, &runtime
->sleep
, wait
);
1496 if (rfile
->output
!= NULL
) {
1497 runtime
= rfile
->output
->runtime
;
1498 poll_wait(file
, &runtime
->sleep
, wait
);
1501 if (rfile
->input
!= NULL
) {
1502 if (snd_rawmidi_ready(rfile
->input
))
1503 mask
|= EPOLLIN
| EPOLLRDNORM
;
1505 if (rfile
->output
!= NULL
) {
1506 if (snd_rawmidi_ready(rfile
->output
))
1507 mask
|= EPOLLOUT
| EPOLLWRNORM
;
1514 #ifdef CONFIG_COMPAT
1515 #include "rawmidi_compat.c"
1517 #define snd_rawmidi_ioctl_compat NULL
1523 static void snd_rawmidi_proc_info_read(struct snd_info_entry
*entry
,
1524 struct snd_info_buffer
*buffer
)
1526 struct snd_rawmidi
*rmidi
;
1527 struct snd_rawmidi_substream
*substream
;
1528 struct snd_rawmidi_runtime
*runtime
;
1530 rmidi
= entry
->private_data
;
1531 snd_iprintf(buffer
, "%s\n\n", rmidi
->name
);
1532 mutex_lock(&rmidi
->open_mutex
);
1533 if (rmidi
->info_flags
& SNDRV_RAWMIDI_INFO_OUTPUT
) {
1534 list_for_each_entry(substream
,
1535 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substreams
,
1539 " Tx bytes : %lu\n",
1541 (unsigned long) substream
->bytes
);
1542 if (substream
->opened
) {
1544 " Owner PID : %d\n",
1545 pid_vnr(substream
->pid
));
1546 runtime
= substream
->runtime
;
1549 " Buffer size : %lu\n"
1551 runtime
->oss
? "OSS compatible" : "native",
1552 (unsigned long) runtime
->buffer_size
,
1553 (unsigned long) runtime
->avail
);
1557 if (rmidi
->info_flags
& SNDRV_RAWMIDI_INFO_INPUT
) {
1558 list_for_each_entry(substream
,
1559 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substreams
,
1563 " Rx bytes : %lu\n",
1565 (unsigned long) substream
->bytes
);
1566 if (substream
->opened
) {
1568 " Owner PID : %d\n",
1569 pid_vnr(substream
->pid
));
1570 runtime
= substream
->runtime
;
1572 " Buffer size : %lu\n"
1574 " Overruns : %lu\n",
1575 (unsigned long) runtime
->buffer_size
,
1576 (unsigned long) runtime
->avail
,
1577 (unsigned long) runtime
->xruns
);
1581 mutex_unlock(&rmidi
->open_mutex
);
1585 * Register functions
1588 static const struct file_operations snd_rawmidi_f_ops
= {
1589 .owner
= THIS_MODULE
,
1590 .read
= snd_rawmidi_read
,
1591 .write
= snd_rawmidi_write
,
1592 .open
= snd_rawmidi_open
,
1593 .release
= snd_rawmidi_release
,
1594 .llseek
= no_llseek
,
1595 .poll
= snd_rawmidi_poll
,
1596 .unlocked_ioctl
= snd_rawmidi_ioctl
,
1597 .compat_ioctl
= snd_rawmidi_ioctl_compat
,
1600 static int snd_rawmidi_alloc_substreams(struct snd_rawmidi
*rmidi
,
1601 struct snd_rawmidi_str
*stream
,
1605 struct snd_rawmidi_substream
*substream
;
1608 for (idx
= 0; idx
< count
; idx
++) {
1609 substream
= kzalloc(sizeof(*substream
), GFP_KERNEL
);
1612 substream
->stream
= direction
;
1613 substream
->number
= idx
;
1614 substream
->rmidi
= rmidi
;
1615 substream
->pstr
= stream
;
1616 list_add_tail(&substream
->list
, &stream
->substreams
);
1617 stream
->substream_count
++;
1622 static void release_rawmidi_device(struct device
*dev
)
1624 kfree(container_of(dev
, struct snd_rawmidi
, dev
));
1628 * snd_rawmidi_new - create a rawmidi instance
1629 * @card: the card instance
1630 * @id: the id string
1631 * @device: the device index
1632 * @output_count: the number of output streams
1633 * @input_count: the number of input streams
1634 * @rrawmidi: the pointer to store the new rawmidi instance
1636 * Creates a new rawmidi instance.
1637 * Use snd_rawmidi_set_ops() to set the operators to the new instance.
1639 * Return: Zero if successful, or a negative error code on failure.
1641 int snd_rawmidi_new(struct snd_card
*card
, char *id
, int device
,
1642 int output_count
, int input_count
,
1643 struct snd_rawmidi
**rrawmidi
)
1645 struct snd_rawmidi
*rmidi
;
1647 static const struct snd_device_ops ops
= {
1648 .dev_free
= snd_rawmidi_dev_free
,
1649 .dev_register
= snd_rawmidi_dev_register
,
1650 .dev_disconnect
= snd_rawmidi_dev_disconnect
,
1653 if (snd_BUG_ON(!card
))
1657 rmidi
= kzalloc(sizeof(*rmidi
), GFP_KERNEL
);
1661 rmidi
->device
= device
;
1662 mutex_init(&rmidi
->open_mutex
);
1663 init_waitqueue_head(&rmidi
->open_wait
);
1664 INIT_LIST_HEAD(&rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substreams
);
1665 INIT_LIST_HEAD(&rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substreams
);
1668 strlcpy(rmidi
->id
, id
, sizeof(rmidi
->id
));
1670 snd_device_initialize(&rmidi
->dev
, card
);
1671 rmidi
->dev
.release
= release_rawmidi_device
;
1672 dev_set_name(&rmidi
->dev
, "midiC%iD%i", card
->number
, device
);
1674 err
= snd_rawmidi_alloc_substreams(rmidi
,
1675 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
],
1676 SNDRV_RAWMIDI_STREAM_INPUT
,
1680 err
= snd_rawmidi_alloc_substreams(rmidi
,
1681 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
],
1682 SNDRV_RAWMIDI_STREAM_OUTPUT
,
1686 err
= snd_device_new(card
, SNDRV_DEV_RAWMIDI
, rmidi
, &ops
);
1695 snd_rawmidi_free(rmidi
);
1698 EXPORT_SYMBOL(snd_rawmidi_new
);
1700 static void snd_rawmidi_free_substreams(struct snd_rawmidi_str
*stream
)
1702 struct snd_rawmidi_substream
*substream
;
1704 while (!list_empty(&stream
->substreams
)) {
1705 substream
= list_entry(stream
->substreams
.next
, struct snd_rawmidi_substream
, list
);
1706 list_del(&substream
->list
);
1711 static int snd_rawmidi_free(struct snd_rawmidi
*rmidi
)
1716 snd_info_free_entry(rmidi
->proc_entry
);
1717 rmidi
->proc_entry
= NULL
;
1718 mutex_lock(®ister_mutex
);
1719 if (rmidi
->ops
&& rmidi
->ops
->dev_unregister
)
1720 rmidi
->ops
->dev_unregister(rmidi
);
1721 mutex_unlock(®ister_mutex
);
1723 snd_rawmidi_free_substreams(&rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
]);
1724 snd_rawmidi_free_substreams(&rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
]);
1725 if (rmidi
->private_free
)
1726 rmidi
->private_free(rmidi
);
1727 put_device(&rmidi
->dev
);
1731 static int snd_rawmidi_dev_free(struct snd_device
*device
)
1733 struct snd_rawmidi
*rmidi
= device
->device_data
;
1735 return snd_rawmidi_free(rmidi
);
1738 #if IS_ENABLED(CONFIG_SND_SEQUENCER)
1739 static void snd_rawmidi_dev_seq_free(struct snd_seq_device
*device
)
1741 struct snd_rawmidi
*rmidi
= device
->private_data
;
1743 rmidi
->seq_dev
= NULL
;
1747 static int snd_rawmidi_dev_register(struct snd_device
*device
)
1750 struct snd_info_entry
*entry
;
1752 struct snd_rawmidi
*rmidi
= device
->device_data
;
1754 if (rmidi
->device
>= SNDRV_RAWMIDI_DEVICES
)
1757 mutex_lock(®ister_mutex
);
1758 if (snd_rawmidi_search(rmidi
->card
, rmidi
->device
))
1761 list_add_tail(&rmidi
->list
, &snd_rawmidi_devices
);
1762 mutex_unlock(®ister_mutex
);
1766 err
= snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI
,
1767 rmidi
->card
, rmidi
->device
,
1768 &snd_rawmidi_f_ops
, rmidi
, &rmidi
->dev
);
1770 rmidi_err(rmidi
, "unable to register\n");
1773 if (rmidi
->ops
&& rmidi
->ops
->dev_register
) {
1774 err
= rmidi
->ops
->dev_register(rmidi
);
1776 goto error_unregister
;
1778 #ifdef CONFIG_SND_OSSEMUL
1780 if ((int)rmidi
->device
== midi_map
[rmidi
->card
->number
]) {
1781 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
,
1782 rmidi
->card
, 0, &snd_rawmidi_f_ops
,
1785 "unable to register OSS rawmidi device %i:%i\n",
1786 rmidi
->card
->number
, 0);
1789 #ifdef SNDRV_OSS_INFO_DEV_MIDI
1790 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI
, rmidi
->card
->number
, rmidi
->name
);
1794 if ((int)rmidi
->device
== amidi_map
[rmidi
->card
->number
]) {
1795 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
,
1796 rmidi
->card
, 1, &snd_rawmidi_f_ops
,
1799 "unable to register OSS rawmidi device %i:%i\n",
1800 rmidi
->card
->number
, 1);
1805 #endif /* CONFIG_SND_OSSEMUL */
1806 sprintf(name
, "midi%d", rmidi
->device
);
1807 entry
= snd_info_create_card_entry(rmidi
->card
, name
, rmidi
->card
->proc_root
);
1809 entry
->private_data
= rmidi
;
1810 entry
->c
.text
.read
= snd_rawmidi_proc_info_read
;
1811 if (snd_info_register(entry
) < 0) {
1812 snd_info_free_entry(entry
);
1816 rmidi
->proc_entry
= entry
;
1817 #if IS_ENABLED(CONFIG_SND_SEQUENCER)
1818 if (!rmidi
->ops
|| !rmidi
->ops
->dev_register
) { /* own registration mechanism */
1819 if (snd_seq_device_new(rmidi
->card
, rmidi
->device
, SNDRV_SEQ_DEV_ID_MIDISYNTH
, 0, &rmidi
->seq_dev
) >= 0) {
1820 rmidi
->seq_dev
->private_data
= rmidi
;
1821 rmidi
->seq_dev
->private_free
= snd_rawmidi_dev_seq_free
;
1822 sprintf(rmidi
->seq_dev
->name
, "MIDI %d-%d", rmidi
->card
->number
, rmidi
->device
);
1823 snd_device_register(rmidi
->card
, rmidi
->seq_dev
);
1830 snd_unregister_device(&rmidi
->dev
);
1832 mutex_lock(®ister_mutex
);
1833 list_del(&rmidi
->list
);
1834 mutex_unlock(®ister_mutex
);
1838 static int snd_rawmidi_dev_disconnect(struct snd_device
*device
)
1840 struct snd_rawmidi
*rmidi
= device
->device_data
;
1843 mutex_lock(®ister_mutex
);
1844 mutex_lock(&rmidi
->open_mutex
);
1845 wake_up(&rmidi
->open_wait
);
1846 list_del_init(&rmidi
->list
);
1847 for (dir
= 0; dir
< 2; dir
++) {
1848 struct snd_rawmidi_substream
*s
;
1850 list_for_each_entry(s
, &rmidi
->streams
[dir
].substreams
, list
) {
1852 wake_up(&s
->runtime
->sleep
);
1856 #ifdef CONFIG_SND_OSSEMUL
1857 if (rmidi
->ossreg
) {
1858 if ((int)rmidi
->device
== midi_map
[rmidi
->card
->number
]) {
1859 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
, rmidi
->card
, 0);
1860 #ifdef SNDRV_OSS_INFO_DEV_MIDI
1861 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI
, rmidi
->card
->number
);
1864 if ((int)rmidi
->device
== amidi_map
[rmidi
->card
->number
])
1865 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
, rmidi
->card
, 1);
1868 #endif /* CONFIG_SND_OSSEMUL */
1869 snd_unregister_device(&rmidi
->dev
);
1870 mutex_unlock(&rmidi
->open_mutex
);
1871 mutex_unlock(®ister_mutex
);
1876 * snd_rawmidi_set_ops - set the rawmidi operators
1877 * @rmidi: the rawmidi instance
1878 * @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX
1879 * @ops: the operator table
1881 * Sets the rawmidi operators for the given stream direction.
1883 void snd_rawmidi_set_ops(struct snd_rawmidi
*rmidi
, int stream
,
1884 const struct snd_rawmidi_ops
*ops
)
1886 struct snd_rawmidi_substream
*substream
;
1888 list_for_each_entry(substream
, &rmidi
->streams
[stream
].substreams
, list
)
1889 substream
->ops
= ops
;
1891 EXPORT_SYMBOL(snd_rawmidi_set_ops
);
1897 static int __init
alsa_rawmidi_init(void)
1900 snd_ctl_register_ioctl(snd_rawmidi_control_ioctl
);
1901 snd_ctl_register_ioctl_compat(snd_rawmidi_control_ioctl
);
1902 #ifdef CONFIG_SND_OSSEMUL
1904 /* check device map table */
1905 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
1906 if (midi_map
[i
] < 0 || midi_map
[i
] >= SNDRV_RAWMIDI_DEVICES
) {
1907 pr_err("ALSA: rawmidi: invalid midi_map[%d] = %d\n",
1911 if (amidi_map
[i
] < 0 || amidi_map
[i
] >= SNDRV_RAWMIDI_DEVICES
) {
1912 pr_err("ALSA: rawmidi: invalid amidi_map[%d] = %d\n",
1918 #endif /* CONFIG_SND_OSSEMUL */
1922 static void __exit
alsa_rawmidi_exit(void)
1924 snd_ctl_unregister_ioctl(snd_rawmidi_control_ioctl
);
1925 snd_ctl_unregister_ioctl_compat(snd_rawmidi_control_ioctl
);
1928 module_init(alsa_rawmidi_init
)
1929 module_exit(alsa_rawmidi_exit
)