2 * Abstract layer for MIDI v1.0 stream
3 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <sound/driver.h>
23 #include <sound/core.h>
24 #include <linux/major.h>
25 #include <linux/init.h>
26 #include <linux/smp_lock.h>
27 #include <linux/sched.h>
28 #include <linux/slab.h>
29 #include <linux/time.h>
30 #include <linux/wait.h>
31 #include <linux/moduleparam.h>
32 #include <linux/delay.h>
33 #include <linux/wait.h>
34 #include <sound/rawmidi.h>
35 #include <sound/info.h>
36 #include <sound/control.h>
37 #include <sound/minors.h>
38 #include <sound/initval.h>
40 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
41 MODULE_DESCRIPTION("Midlevel RawMidi code for ALSA.");
42 MODULE_LICENSE("GPL");
44 #ifdef CONFIG_SND_OSSEMUL
45 static int midi_map
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
-1)] = 0};
46 static int amidi_map
[SNDRV_CARDS
] = {[0 ... (SNDRV_CARDS
-1)] = 1};
47 module_param_array(midi_map
, int, NULL
, 0444);
48 MODULE_PARM_DESC(midi_map
, "Raw MIDI device number assigned to 1st OSS device.");
49 module_param_array(amidi_map
, int, NULL
, 0444);
50 MODULE_PARM_DESC(amidi_map
, "Raw MIDI device number assigned to 2nd OSS device.");
51 #endif /* CONFIG_SND_OSSEMUL */
53 static int snd_rawmidi_free(struct snd_rawmidi
*rawmidi
);
54 static int snd_rawmidi_dev_free(struct snd_device
*device
);
55 static int snd_rawmidi_dev_register(struct snd_device
*device
);
56 static int snd_rawmidi_dev_disconnect(struct snd_device
*device
);
57 static int snd_rawmidi_dev_unregister(struct snd_device
*device
);
59 static LIST_HEAD(snd_rawmidi_devices
);
60 static DECLARE_MUTEX(register_mutex
);
62 static struct snd_rawmidi
*snd_rawmidi_search(struct snd_card
*card
, int device
)
65 struct snd_rawmidi
*rawmidi
;
67 list_for_each(p
, &snd_rawmidi_devices
) {
68 rawmidi
= list_entry(p
, struct snd_rawmidi
, list
);
69 if (rawmidi
->card
== card
&& rawmidi
->device
== device
)
75 static inline unsigned short snd_rawmidi_file_flags(struct file
*file
)
77 switch (file
->f_mode
& (FMODE_READ
| FMODE_WRITE
)) {
79 return SNDRV_RAWMIDI_LFLG_OUTPUT
;
81 return SNDRV_RAWMIDI_LFLG_INPUT
;
83 return SNDRV_RAWMIDI_LFLG_OPEN
;
87 static inline int snd_rawmidi_ready(struct snd_rawmidi_substream
*substream
)
89 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
90 return runtime
->avail
>= runtime
->avail_min
;
93 static inline int snd_rawmidi_ready_append(struct snd_rawmidi_substream
*substream
,
96 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
97 return runtime
->avail
>= runtime
->avail_min
&&
98 (!substream
->append
|| runtime
->avail
>= count
);
101 static void snd_rawmidi_input_event_tasklet(unsigned long data
)
103 struct snd_rawmidi_substream
*substream
= (struct snd_rawmidi_substream
*)data
;
104 substream
->runtime
->event(substream
);
107 static void snd_rawmidi_output_trigger_tasklet(unsigned long data
)
109 struct snd_rawmidi_substream
*substream
= (struct snd_rawmidi_substream
*)data
;
110 substream
->ops
->trigger(substream
, 1);
113 static int snd_rawmidi_runtime_create(struct snd_rawmidi_substream
*substream
)
115 struct snd_rawmidi_runtime
*runtime
;
117 if ((runtime
= kzalloc(sizeof(*runtime
), GFP_KERNEL
)) == NULL
)
119 spin_lock_init(&runtime
->lock
);
120 init_waitqueue_head(&runtime
->sleep
);
121 if (substream
->stream
== SNDRV_RAWMIDI_STREAM_INPUT
)
122 tasklet_init(&runtime
->tasklet
,
123 snd_rawmidi_input_event_tasklet
,
124 (unsigned long)substream
);
126 tasklet_init(&runtime
->tasklet
,
127 snd_rawmidi_output_trigger_tasklet
,
128 (unsigned long)substream
);
129 runtime
->event
= NULL
;
130 runtime
->buffer_size
= PAGE_SIZE
;
131 runtime
->avail_min
= 1;
132 if (substream
->stream
== SNDRV_RAWMIDI_STREAM_INPUT
)
135 runtime
->avail
= runtime
->buffer_size
;
136 if ((runtime
->buffer
= kmalloc(runtime
->buffer_size
, GFP_KERNEL
)) == NULL
) {
140 runtime
->appl_ptr
= runtime
->hw_ptr
= 0;
141 substream
->runtime
= runtime
;
145 static int snd_rawmidi_runtime_free(struct snd_rawmidi_substream
*substream
)
147 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
149 kfree(runtime
->buffer
);
151 substream
->runtime
= NULL
;
155 static inline void snd_rawmidi_output_trigger(struct snd_rawmidi_substream
*substream
,int up
)
158 tasklet_hi_schedule(&substream
->runtime
->tasklet
);
160 tasklet_kill(&substream
->runtime
->tasklet
);
161 substream
->ops
->trigger(substream
, 0);
165 static void snd_rawmidi_input_trigger(struct snd_rawmidi_substream
*substream
, int up
)
167 substream
->ops
->trigger(substream
, up
);
168 if (!up
&& substream
->runtime
->event
)
169 tasklet_kill(&substream
->runtime
->tasklet
);
172 int snd_rawmidi_drop_output(struct snd_rawmidi_substream
*substream
)
175 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
177 snd_rawmidi_output_trigger(substream
, 0);
179 spin_lock_irqsave(&runtime
->lock
, flags
);
180 runtime
->appl_ptr
= runtime
->hw_ptr
= 0;
181 runtime
->avail
= runtime
->buffer_size
;
182 spin_unlock_irqrestore(&runtime
->lock
, flags
);
186 int snd_rawmidi_drain_output(struct snd_rawmidi_substream
*substream
)
190 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
194 timeout
= wait_event_interruptible_timeout(runtime
->sleep
,
195 (runtime
->avail
>= runtime
->buffer_size
),
197 if (signal_pending(current
))
199 if (runtime
->avail
< runtime
->buffer_size
&& !timeout
) {
200 snd_printk(KERN_WARNING
"rawmidi drain error (avail = %li, buffer_size = %li)\n", (long)runtime
->avail
, (long)runtime
->buffer_size
);
204 if (err
!= -ERESTARTSYS
) {
205 /* we need wait a while to make sure that Tx FIFOs are empty */
206 if (substream
->ops
->drain
)
207 substream
->ops
->drain(substream
);
210 snd_rawmidi_drop_output(substream
);
215 int snd_rawmidi_drain_input(struct snd_rawmidi_substream
*substream
)
218 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
220 snd_rawmidi_input_trigger(substream
, 0);
222 spin_lock_irqsave(&runtime
->lock
, flags
);
223 runtime
->appl_ptr
= runtime
->hw_ptr
= 0;
225 spin_unlock_irqrestore(&runtime
->lock
, flags
);
229 int snd_rawmidi_kernel_open(struct snd_card
*card
, int device
, int subdevice
,
230 int mode
, struct snd_rawmidi_file
* rfile
)
232 struct snd_rawmidi
*rmidi
;
233 struct list_head
*list1
, *list2
;
234 struct snd_rawmidi_substream
*sinput
= NULL
, *soutput
= NULL
;
235 struct snd_rawmidi_runtime
*input
= NULL
, *output
= NULL
;
239 rfile
->input
= rfile
->output
= NULL
;
240 down(®ister_mutex
);
241 rmidi
= snd_rawmidi_search(card
, device
);
247 if (!try_module_get(rmidi
->card
->module
)) {
251 if (!(mode
& SNDRV_RAWMIDI_LFLG_NOOPENLOCK
))
252 down(&rmidi
->open_mutex
);
253 if (mode
& SNDRV_RAWMIDI_LFLG_INPUT
) {
254 if (!(rmidi
->info_flags
& SNDRV_RAWMIDI_INFO_INPUT
)) {
258 if (subdevice
>= 0 && (unsigned int)subdevice
>= rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substream_count
) {
262 if (rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substream_opened
>=
263 rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substream_count
) {
268 if (mode
& SNDRV_RAWMIDI_LFLG_OUTPUT
) {
269 if (!(rmidi
->info_flags
& SNDRV_RAWMIDI_INFO_OUTPUT
)) {
273 if (subdevice
>= 0 && (unsigned int)subdevice
>= rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substream_count
) {
277 if (rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substream_opened
>=
278 rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substream_count
) {
283 list1
= rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substreams
.next
;
285 if (list1
== &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substreams
) {
287 if (mode
& SNDRV_RAWMIDI_LFLG_INPUT
) {
293 sinput
= list_entry(list1
, struct snd_rawmidi_substream
, list
);
294 if ((mode
& SNDRV_RAWMIDI_LFLG_INPUT
) && sinput
->opened
)
296 if (subdevice
< 0 || (subdevice
>= 0 && subdevice
== sinput
->number
))
301 list2
= rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substreams
.next
;
303 if (list2
== &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substreams
) {
305 if (mode
& SNDRV_RAWMIDI_LFLG_OUTPUT
) {
311 soutput
= list_entry(list2
, struct snd_rawmidi_substream
, list
);
312 if (mode
& SNDRV_RAWMIDI_LFLG_OUTPUT
) {
313 if (mode
& SNDRV_RAWMIDI_LFLG_APPEND
) {
314 if (soutput
->opened
&& !soutput
->append
)
321 if (subdevice
< 0 || (subdevice
>= 0 && subdevice
== soutput
->number
))
326 if (mode
& SNDRV_RAWMIDI_LFLG_INPUT
) {
327 if ((err
= snd_rawmidi_runtime_create(sinput
)) < 0)
329 input
= sinput
->runtime
;
330 if ((err
= sinput
->ops
->open(sinput
)) < 0)
333 rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substream_opened
++;
337 if (mode
& SNDRV_RAWMIDI_LFLG_OUTPUT
) {
340 if ((err
= snd_rawmidi_runtime_create(soutput
)) < 0) {
341 if (mode
& SNDRV_RAWMIDI_LFLG_INPUT
)
342 sinput
->ops
->close(sinput
);
345 output
= soutput
->runtime
;
346 if ((err
= soutput
->ops
->open(soutput
)) < 0) {
347 if (mode
& SNDRV_RAWMIDI_LFLG_INPUT
)
348 sinput
->ops
->close(sinput
);
353 if (mode
& SNDRV_RAWMIDI_LFLG_APPEND
)
355 if (soutput
->use_count
++ == 0)
356 soutput
->active_sensing
= 1;
357 rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substream_opened
++;
361 if (!(mode
& SNDRV_RAWMIDI_LFLG_NOOPENLOCK
))
362 up(&rmidi
->open_mutex
);
364 rfile
->rmidi
= rmidi
;
365 rfile
->input
= sinput
;
366 rfile
->output
= soutput
;
372 snd_rawmidi_runtime_free(sinput
);
374 snd_rawmidi_runtime_free(soutput
);
375 module_put(rmidi
->card
->module
);
376 if (!(mode
& SNDRV_RAWMIDI_LFLG_NOOPENLOCK
))
377 up(&rmidi
->open_mutex
);
382 static int snd_rawmidi_open(struct inode
*inode
, struct file
*file
)
384 int maj
= imajor(inode
);
385 struct snd_card
*card
;
387 unsigned short fflags
;
389 struct snd_rawmidi
*rmidi
;
390 struct snd_rawmidi_file
*rawmidi_file
;
392 struct list_head
*list
;
393 struct snd_ctl_file
*kctl
;
395 if (maj
== snd_major
) {
396 rmidi
= snd_lookup_minor_data(iminor(inode
),
397 SNDRV_DEVICE_TYPE_RAWMIDI
);
398 #ifdef CONFIG_SND_OSSEMUL
399 } else if (maj
== SOUND_MAJOR
) {
400 rmidi
= snd_lookup_oss_minor_data(iminor(inode
),
401 SNDRV_OSS_DEVICE_TYPE_MIDI
);
408 if ((file
->f_flags
& O_APPEND
) && !(file
->f_flags
& O_NONBLOCK
))
409 return -EINVAL
; /* invalid combination */
411 err
= snd_card_file_add(card
, file
);
414 fflags
= snd_rawmidi_file_flags(file
);
415 if ((file
->f_flags
& O_APPEND
) || maj
== SOUND_MAJOR
) /* OSS emul? */
416 fflags
|= SNDRV_RAWMIDI_LFLG_APPEND
;
417 fflags
|= SNDRV_RAWMIDI_LFLG_NOOPENLOCK
;
418 rawmidi_file
= kmalloc(sizeof(*rawmidi_file
), GFP_KERNEL
);
419 if (rawmidi_file
== NULL
) {
420 snd_card_file_remove(card
, file
);
423 init_waitqueue_entry(&wait
, current
);
424 add_wait_queue(&rmidi
->open_wait
, &wait
);
425 down(&rmidi
->open_mutex
);
428 down_read(&card
->controls_rwsem
);
429 list_for_each(list
, &card
->ctl_files
) {
430 kctl
= snd_ctl_file(list
);
431 if (kctl
->pid
== current
->pid
) {
432 subdevice
= kctl
->prefer_rawmidi_subdevice
;
436 up_read(&card
->controls_rwsem
);
437 err
= snd_rawmidi_kernel_open(rmidi
->card
, rmidi
->device
,
438 subdevice
, fflags
, rawmidi_file
);
441 if (err
== -EAGAIN
) {
442 if (file
->f_flags
& O_NONBLOCK
) {
448 set_current_state(TASK_INTERRUPTIBLE
);
449 up(&rmidi
->open_mutex
);
451 down(&rmidi
->open_mutex
);
452 if (signal_pending(current
)) {
457 #ifdef CONFIG_SND_OSSEMUL
458 if (rawmidi_file
->input
&& rawmidi_file
->input
->runtime
)
459 rawmidi_file
->input
->runtime
->oss
= (maj
== SOUND_MAJOR
);
460 if (rawmidi_file
->output
&& rawmidi_file
->output
->runtime
)
461 rawmidi_file
->output
->runtime
->oss
= (maj
== SOUND_MAJOR
);
463 remove_wait_queue(&rmidi
->open_wait
, &wait
);
465 file
->private_data
= rawmidi_file
;
467 snd_card_file_remove(card
, file
);
470 up(&rmidi
->open_mutex
);
474 int snd_rawmidi_kernel_release(struct snd_rawmidi_file
* rfile
)
476 struct snd_rawmidi
*rmidi
;
477 struct snd_rawmidi_substream
*substream
;
478 struct snd_rawmidi_runtime
*runtime
;
480 snd_assert(rfile
!= NULL
, return -ENXIO
);
481 snd_assert(rfile
->input
!= NULL
|| rfile
->output
!= NULL
, return -ENXIO
);
482 rmidi
= rfile
->rmidi
;
483 down(&rmidi
->open_mutex
);
484 if (rfile
->input
!= NULL
) {
485 substream
= rfile
->input
;
487 runtime
= substream
->runtime
;
488 snd_rawmidi_input_trigger(substream
, 0);
489 substream
->ops
->close(substream
);
490 if (runtime
->private_free
!= NULL
)
491 runtime
->private_free(substream
);
492 snd_rawmidi_runtime_free(substream
);
493 substream
->opened
= 0;
494 rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substream_opened
--;
496 if (rfile
->output
!= NULL
) {
497 substream
= rfile
->output
;
498 rfile
->output
= NULL
;
499 if (--substream
->use_count
== 0) {
500 runtime
= substream
->runtime
;
501 if (substream
->active_sensing
) {
502 unsigned char buf
= 0xfe;
503 /* sending single active sensing message to shut the device up */
504 snd_rawmidi_kernel_write(substream
, &buf
, 1);
506 if (snd_rawmidi_drain_output(substream
) == -ERESTARTSYS
)
507 snd_rawmidi_output_trigger(substream
, 0);
508 substream
->ops
->close(substream
);
509 if (runtime
->private_free
!= NULL
)
510 runtime
->private_free(substream
);
511 snd_rawmidi_runtime_free(substream
);
512 substream
->opened
= 0;
513 substream
->append
= 0;
515 rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substream_opened
--;
517 up(&rmidi
->open_mutex
);
518 module_put(rmidi
->card
->module
);
522 static int snd_rawmidi_release(struct inode
*inode
, struct file
*file
)
524 struct snd_rawmidi_file
*rfile
;
525 struct snd_rawmidi
*rmidi
;
528 rfile
= file
->private_data
;
529 err
= snd_rawmidi_kernel_release(rfile
);
530 rmidi
= rfile
->rmidi
;
531 wake_up(&rmidi
->open_wait
);
533 snd_card_file_remove(rmidi
->card
, file
);
537 static int snd_rawmidi_info(struct snd_rawmidi_substream
*substream
,
538 struct snd_rawmidi_info
*info
)
540 struct snd_rawmidi
*rmidi
;
542 if (substream
== NULL
)
544 rmidi
= substream
->rmidi
;
545 memset(info
, 0, sizeof(*info
));
546 info
->card
= rmidi
->card
->number
;
547 info
->device
= rmidi
->device
;
548 info
->subdevice
= substream
->number
;
549 info
->stream
= substream
->stream
;
550 info
->flags
= rmidi
->info_flags
;
551 strcpy(info
->id
, rmidi
->id
);
552 strcpy(info
->name
, rmidi
->name
);
553 strcpy(info
->subname
, substream
->name
);
554 info
->subdevices_count
= substream
->pstr
->substream_count
;
555 info
->subdevices_avail
= (substream
->pstr
->substream_count
-
556 substream
->pstr
->substream_opened
);
560 static int snd_rawmidi_info_user(struct snd_rawmidi_substream
*substream
,
561 struct snd_rawmidi_info __user
* _info
)
563 struct snd_rawmidi_info info
;
565 if ((err
= snd_rawmidi_info(substream
, &info
)) < 0)
567 if (copy_to_user(_info
, &info
, sizeof(struct snd_rawmidi_info
)))
572 int snd_rawmidi_info_select(struct snd_card
*card
, struct snd_rawmidi_info
*info
)
574 struct snd_rawmidi
*rmidi
;
575 struct snd_rawmidi_str
*pstr
;
576 struct snd_rawmidi_substream
*substream
;
577 struct list_head
*list
;
579 down(®ister_mutex
);
580 rmidi
= snd_rawmidi_search(card
, info
->device
);
584 if (info
->stream
< 0 || info
->stream
> 1)
586 pstr
= &rmidi
->streams
[info
->stream
];
587 if (pstr
->substream_count
== 0)
589 if (info
->subdevice
>= pstr
->substream_count
)
591 list_for_each(list
, &pstr
->substreams
) {
592 substream
= list_entry(list
, struct snd_rawmidi_substream
, list
);
593 if ((unsigned int)substream
->number
== info
->subdevice
)
594 return snd_rawmidi_info(substream
, info
);
599 static int snd_rawmidi_info_select_user(struct snd_card
*card
,
600 struct snd_rawmidi_info __user
*_info
)
603 struct snd_rawmidi_info info
;
604 if (get_user(info
.device
, &_info
->device
))
606 if (get_user(info
.stream
, &_info
->stream
))
608 if (get_user(info
.subdevice
, &_info
->subdevice
))
610 if ((err
= snd_rawmidi_info_select(card
, &info
)) < 0)
612 if (copy_to_user(_info
, &info
, sizeof(struct snd_rawmidi_info
)))
617 int snd_rawmidi_output_params(struct snd_rawmidi_substream
*substream
,
618 struct snd_rawmidi_params
* params
)
621 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
623 if (substream
->append
&& substream
->use_count
> 1)
625 snd_rawmidi_drain_output(substream
);
626 if (params
->buffer_size
< 32 || params
->buffer_size
> 1024L * 1024L) {
629 if (params
->avail_min
< 1 || params
->avail_min
> params
->buffer_size
) {
632 if (params
->buffer_size
!= runtime
->buffer_size
) {
633 if ((newbuf
= (char *) kmalloc(params
->buffer_size
, GFP_KERNEL
)) == NULL
)
635 kfree(runtime
->buffer
);
636 runtime
->buffer
= newbuf
;
637 runtime
->buffer_size
= params
->buffer_size
;
638 runtime
->avail
= runtime
->buffer_size
;
640 runtime
->avail_min
= params
->avail_min
;
641 substream
->active_sensing
= !params
->no_active_sensing
;
645 int snd_rawmidi_input_params(struct snd_rawmidi_substream
*substream
,
646 struct snd_rawmidi_params
* params
)
649 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
651 snd_rawmidi_drain_input(substream
);
652 if (params
->buffer_size
< 32 || params
->buffer_size
> 1024L * 1024L) {
655 if (params
->avail_min
< 1 || params
->avail_min
> params
->buffer_size
) {
658 if (params
->buffer_size
!= runtime
->buffer_size
) {
659 if ((newbuf
= (char *) kmalloc(params
->buffer_size
, GFP_KERNEL
)) == NULL
)
661 kfree(runtime
->buffer
);
662 runtime
->buffer
= newbuf
;
663 runtime
->buffer_size
= params
->buffer_size
;
665 runtime
->avail_min
= params
->avail_min
;
669 static int snd_rawmidi_output_status(struct snd_rawmidi_substream
*substream
,
670 struct snd_rawmidi_status
* status
)
672 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
674 memset(status
, 0, sizeof(*status
));
675 status
->stream
= SNDRV_RAWMIDI_STREAM_OUTPUT
;
676 spin_lock_irq(&runtime
->lock
);
677 status
->avail
= runtime
->avail
;
678 spin_unlock_irq(&runtime
->lock
);
682 static int snd_rawmidi_input_status(struct snd_rawmidi_substream
*substream
,
683 struct snd_rawmidi_status
* status
)
685 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
687 memset(status
, 0, sizeof(*status
));
688 status
->stream
= SNDRV_RAWMIDI_STREAM_INPUT
;
689 spin_lock_irq(&runtime
->lock
);
690 status
->avail
= runtime
->avail
;
691 status
->xruns
= runtime
->xruns
;
693 spin_unlock_irq(&runtime
->lock
);
697 static long snd_rawmidi_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
699 struct snd_rawmidi_file
*rfile
;
700 void __user
*argp
= (void __user
*)arg
;
702 rfile
= file
->private_data
;
703 if (((cmd
>> 8) & 0xff) != 'W')
706 case SNDRV_RAWMIDI_IOCTL_PVERSION
:
707 return put_user(SNDRV_RAWMIDI_VERSION
, (int __user
*)argp
) ? -EFAULT
: 0;
708 case SNDRV_RAWMIDI_IOCTL_INFO
:
711 struct snd_rawmidi_info __user
*info
= argp
;
712 if (get_user(stream
, &info
->stream
))
715 case SNDRV_RAWMIDI_STREAM_INPUT
:
716 return snd_rawmidi_info_user(rfile
->input
, info
);
717 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
718 return snd_rawmidi_info_user(rfile
->output
, info
);
723 case SNDRV_RAWMIDI_IOCTL_PARAMS
:
725 struct snd_rawmidi_params params
;
726 if (copy_from_user(¶ms
, argp
, sizeof(struct snd_rawmidi_params
)))
728 switch (params
.stream
) {
729 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
730 if (rfile
->output
== NULL
)
732 return snd_rawmidi_output_params(rfile
->output
, ¶ms
);
733 case SNDRV_RAWMIDI_STREAM_INPUT
:
734 if (rfile
->input
== NULL
)
736 return snd_rawmidi_input_params(rfile
->input
, ¶ms
);
741 case SNDRV_RAWMIDI_IOCTL_STATUS
:
744 struct snd_rawmidi_status status
;
745 if (copy_from_user(&status
, argp
, sizeof(struct snd_rawmidi_status
)))
747 switch (status
.stream
) {
748 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
749 if (rfile
->output
== NULL
)
751 err
= snd_rawmidi_output_status(rfile
->output
, &status
);
753 case SNDRV_RAWMIDI_STREAM_INPUT
:
754 if (rfile
->input
== NULL
)
756 err
= snd_rawmidi_input_status(rfile
->input
, &status
);
763 if (copy_to_user(argp
, &status
, sizeof(struct snd_rawmidi_status
)))
767 case SNDRV_RAWMIDI_IOCTL_DROP
:
770 if (get_user(val
, (int __user
*) argp
))
773 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
774 if (rfile
->output
== NULL
)
776 return snd_rawmidi_drop_output(rfile
->output
);
781 case SNDRV_RAWMIDI_IOCTL_DRAIN
:
784 if (get_user(val
, (int __user
*) argp
))
787 case SNDRV_RAWMIDI_STREAM_OUTPUT
:
788 if (rfile
->output
== NULL
)
790 return snd_rawmidi_drain_output(rfile
->output
);
791 case SNDRV_RAWMIDI_STREAM_INPUT
:
792 if (rfile
->input
== NULL
)
794 return snd_rawmidi_drain_input(rfile
->input
);
799 #ifdef CONFIG_SND_DEBUG
801 snd_printk(KERN_WARNING
"rawmidi: unknown command = 0x%x\n", cmd
);
807 static int snd_rawmidi_control_ioctl(struct snd_card
*card
,
808 struct snd_ctl_file
*control
,
812 void __user
*argp
= (void __user
*)arg
;
815 case SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE
:
819 if (get_user(device
, (int __user
*)argp
))
821 down(®ister_mutex
);
822 device
= device
< 0 ? 0 : device
+ 1;
823 while (device
< SNDRV_RAWMIDI_DEVICES
) {
824 if (snd_rawmidi_search(card
, device
))
828 if (device
== SNDRV_RAWMIDI_DEVICES
)
831 if (put_user(device
, (int __user
*)argp
))
835 case SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE
:
839 if (get_user(val
, (int __user
*)argp
))
841 control
->prefer_rawmidi_subdevice
= val
;
844 case SNDRV_CTL_IOCTL_RAWMIDI_INFO
:
845 return snd_rawmidi_info_select_user(card
, argp
);
851 * snd_rawmidi_receive - receive the input data from the device
852 * @substream: the rawmidi substream
853 * @buffer: the buffer pointer
854 * @count: the data size to read
856 * Reads the data from the internal buffer.
858 * Returns the size of read data, or a negative error code on failure.
860 int snd_rawmidi_receive(struct snd_rawmidi_substream
*substream
,
861 const unsigned char *buffer
, int count
)
864 int result
= 0, count1
;
865 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
867 if (runtime
->buffer
== NULL
) {
868 snd_printd("snd_rawmidi_receive: input is not active!!!\n");
871 spin_lock_irqsave(&runtime
->lock
, flags
);
872 if (count
== 1) { /* special case, faster code */
874 if (runtime
->avail
< runtime
->buffer_size
) {
875 runtime
->buffer
[runtime
->hw_ptr
++] = buffer
[0];
876 runtime
->hw_ptr
%= runtime
->buffer_size
;
883 substream
->bytes
+= count
;
884 count1
= runtime
->buffer_size
- runtime
->hw_ptr
;
887 if (count1
> (int)(runtime
->buffer_size
- runtime
->avail
))
888 count1
= runtime
->buffer_size
- runtime
->avail
;
889 memcpy(runtime
->buffer
+ runtime
->hw_ptr
, buffer
, count1
);
890 runtime
->hw_ptr
+= count1
;
891 runtime
->hw_ptr
%= runtime
->buffer_size
;
892 runtime
->avail
+= count1
;
898 if (count1
> (int)(runtime
->buffer_size
- runtime
->avail
)) {
899 count1
= runtime
->buffer_size
- runtime
->avail
;
900 runtime
->xruns
+= count
- count1
;
903 memcpy(runtime
->buffer
, buffer
, count1
);
904 runtime
->hw_ptr
= count1
;
905 runtime
->avail
+= count1
;
912 tasklet_hi_schedule(&runtime
->tasklet
);
913 else if (snd_rawmidi_ready(substream
))
914 wake_up(&runtime
->sleep
);
916 spin_unlock_irqrestore(&runtime
->lock
, flags
);
920 static long snd_rawmidi_kernel_read1(struct snd_rawmidi_substream
*substream
,
921 unsigned char *buf
, long count
, int kernel
)
924 long result
= 0, count1
;
925 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
927 while (count
> 0 && runtime
->avail
) {
928 count1
= runtime
->buffer_size
- runtime
->appl_ptr
;
931 spin_lock_irqsave(&runtime
->lock
, flags
);
932 if (count1
> (int)runtime
->avail
)
933 count1
= runtime
->avail
;
935 memcpy(buf
+ result
, runtime
->buffer
+ runtime
->appl_ptr
, count1
);
937 spin_unlock_irqrestore(&runtime
->lock
, flags
);
938 if (copy_to_user((char __user
*)buf
+ result
,
939 runtime
->buffer
+ runtime
->appl_ptr
, count1
)) {
940 return result
> 0 ? result
: -EFAULT
;
942 spin_lock_irqsave(&runtime
->lock
, flags
);
944 runtime
->appl_ptr
+= count1
;
945 runtime
->appl_ptr
%= runtime
->buffer_size
;
946 runtime
->avail
-= count1
;
947 spin_unlock_irqrestore(&runtime
->lock
, flags
);
954 long snd_rawmidi_kernel_read(struct snd_rawmidi_substream
*substream
,
955 unsigned char *buf
, long count
)
957 snd_rawmidi_input_trigger(substream
, 1);
958 return snd_rawmidi_kernel_read1(substream
, buf
, count
, 1);
961 static ssize_t
snd_rawmidi_read(struct file
*file
, char __user
*buf
, size_t count
,
966 struct snd_rawmidi_file
*rfile
;
967 struct snd_rawmidi_substream
*substream
;
968 struct snd_rawmidi_runtime
*runtime
;
970 rfile
= file
->private_data
;
971 substream
= rfile
->input
;
972 if (substream
== NULL
)
974 runtime
= substream
->runtime
;
975 snd_rawmidi_input_trigger(substream
, 1);
978 spin_lock_irq(&runtime
->lock
);
979 while (!snd_rawmidi_ready(substream
)) {
981 if ((file
->f_flags
& O_NONBLOCK
) != 0 || result
> 0) {
982 spin_unlock_irq(&runtime
->lock
);
983 return result
> 0 ? result
: -EAGAIN
;
985 init_waitqueue_entry(&wait
, current
);
986 add_wait_queue(&runtime
->sleep
, &wait
);
987 set_current_state(TASK_INTERRUPTIBLE
);
988 spin_unlock_irq(&runtime
->lock
);
990 remove_wait_queue(&runtime
->sleep
, &wait
);
991 if (signal_pending(current
))
992 return result
> 0 ? result
: -ERESTARTSYS
;
994 return result
> 0 ? result
: -EIO
;
995 spin_lock_irq(&runtime
->lock
);
997 spin_unlock_irq(&runtime
->lock
);
998 count1
= snd_rawmidi_kernel_read1(substream
,
999 (unsigned char __force
*)buf
,
1002 return result
> 0 ? result
: count1
;
1011 * snd_rawmidi_transmit_empty - check whether the output buffer is empty
1012 * @substream: the rawmidi substream
1014 * Returns 1 if the internal output buffer is empty, 0 if not.
1016 int snd_rawmidi_transmit_empty(struct snd_rawmidi_substream
*substream
)
1018 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1020 unsigned long flags
;
1022 if (runtime
->buffer
== NULL
) {
1023 snd_printd("snd_rawmidi_transmit_empty: output is not active!!!\n");
1026 spin_lock_irqsave(&runtime
->lock
, flags
);
1027 result
= runtime
->avail
>= runtime
->buffer_size
;
1028 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1033 * snd_rawmidi_transmit_peek - copy data from the internal buffer
1034 * @substream: the rawmidi substream
1035 * @buffer: the buffer pointer
1036 * @count: data size to transfer
1038 * Copies data from the internal output buffer to the given buffer.
1040 * Call this in the interrupt handler when the midi output is ready,
1041 * and call snd_rawmidi_transmit_ack() after the transmission is
1044 * Returns the size of copied data, or a negative error code on failure.
1046 int snd_rawmidi_transmit_peek(struct snd_rawmidi_substream
*substream
,
1047 unsigned char *buffer
, int count
)
1049 unsigned long flags
;
1051 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1053 if (runtime
->buffer
== NULL
) {
1054 snd_printd("snd_rawmidi_transmit_peek: output is not active!!!\n");
1058 spin_lock_irqsave(&runtime
->lock
, flags
);
1059 if (runtime
->avail
>= runtime
->buffer_size
) {
1060 /* warning: lowlevel layer MUST trigger down the hardware */
1063 if (count
== 1) { /* special case, faster code */
1064 *buffer
= runtime
->buffer
[runtime
->hw_ptr
];
1067 count1
= runtime
->buffer_size
- runtime
->hw_ptr
;
1070 if (count1
> (int)(runtime
->buffer_size
- runtime
->avail
))
1071 count1
= runtime
->buffer_size
- runtime
->avail
;
1072 memcpy(buffer
, runtime
->buffer
+ runtime
->hw_ptr
, count1
);
1076 if (count
> (int)(runtime
->buffer_size
- runtime
->avail
- count1
))
1077 count
= runtime
->buffer_size
- runtime
->avail
- count1
;
1078 memcpy(buffer
+ count1
, runtime
->buffer
, count
);
1083 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1088 * snd_rawmidi_transmit_ack - acknowledge the transmission
1089 * @substream: the rawmidi substream
1090 * @count: the tranferred count
1092 * Advances the hardware pointer for the internal output buffer with
1093 * the given size and updates the condition.
1094 * Call after the transmission is finished.
1096 * Returns the advanced size if successful, or a negative error code on failure.
1098 int snd_rawmidi_transmit_ack(struct snd_rawmidi_substream
*substream
, int count
)
1100 unsigned long flags
;
1101 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1103 if (runtime
->buffer
== NULL
) {
1104 snd_printd("snd_rawmidi_transmit_ack: output is not active!!!\n");
1107 spin_lock_irqsave(&runtime
->lock
, flags
);
1108 snd_assert(runtime
->avail
+ count
<= runtime
->buffer_size
, );
1109 runtime
->hw_ptr
+= count
;
1110 runtime
->hw_ptr
%= runtime
->buffer_size
;
1111 runtime
->avail
+= count
;
1112 substream
->bytes
+= count
;
1114 if (runtime
->drain
|| snd_rawmidi_ready(substream
))
1115 wake_up(&runtime
->sleep
);
1117 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1122 * snd_rawmidi_transmit - copy from the buffer to the device
1123 * @substream: the rawmidi substream
1124 * @buffer: the buffer pointer
1125 * @count: the data size to transfer
1127 * Copies data from the buffer to the device and advances the pointer.
1129 * Returns the copied size if successful, or a negative error code on failure.
1131 int snd_rawmidi_transmit(struct snd_rawmidi_substream
*substream
,
1132 unsigned char *buffer
, int count
)
1134 count
= snd_rawmidi_transmit_peek(substream
, buffer
, count
);
1137 return snd_rawmidi_transmit_ack(substream
, count
);
1140 static long snd_rawmidi_kernel_write1(struct snd_rawmidi_substream
*substream
,
1141 const unsigned char *buf
, long count
, int kernel
)
1143 unsigned long flags
;
1144 long count1
, result
;
1145 struct snd_rawmidi_runtime
*runtime
= substream
->runtime
;
1147 snd_assert(buf
!= NULL
, return -EINVAL
);
1148 snd_assert(runtime
->buffer
!= NULL
, return -EINVAL
);
1151 spin_lock_irqsave(&runtime
->lock
, flags
);
1152 if (substream
->append
) {
1153 if ((long)runtime
->avail
< count
) {
1154 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1158 while (count
> 0 && runtime
->avail
> 0) {
1159 count1
= runtime
->buffer_size
- runtime
->appl_ptr
;
1162 if (count1
> (long)runtime
->avail
)
1163 count1
= runtime
->avail
;
1165 memcpy(runtime
->buffer
+ runtime
->appl_ptr
, buf
, count1
);
1167 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1168 if (copy_from_user(runtime
->buffer
+ runtime
->appl_ptr
,
1169 (char __user
*)buf
, count1
)) {
1170 spin_lock_irqsave(&runtime
->lock
, flags
);
1171 result
= result
> 0 ? result
: -EFAULT
;
1174 spin_lock_irqsave(&runtime
->lock
, flags
);
1176 runtime
->appl_ptr
+= count1
;
1177 runtime
->appl_ptr
%= runtime
->buffer_size
;
1178 runtime
->avail
-= count1
;
1184 count1
= runtime
->avail
< runtime
->buffer_size
;
1185 spin_unlock_irqrestore(&runtime
->lock
, flags
);
1187 snd_rawmidi_output_trigger(substream
, 1);
1191 long snd_rawmidi_kernel_write(struct snd_rawmidi_substream
*substream
,
1192 const unsigned char *buf
, long count
)
1194 return snd_rawmidi_kernel_write1(substream
, buf
, count
, 1);
1197 static ssize_t
snd_rawmidi_write(struct file
*file
, const char __user
*buf
,
1198 size_t count
, loff_t
*offset
)
1200 long result
, timeout
;
1202 struct snd_rawmidi_file
*rfile
;
1203 struct snd_rawmidi_runtime
*runtime
;
1204 struct snd_rawmidi_substream
*substream
;
1206 rfile
= file
->private_data
;
1207 substream
= rfile
->output
;
1208 runtime
= substream
->runtime
;
1209 /* we cannot put an atomic message to our buffer */
1210 if (substream
->append
&& count
> runtime
->buffer_size
)
1214 spin_lock_irq(&runtime
->lock
);
1215 while (!snd_rawmidi_ready_append(substream
, count
)) {
1217 if (file
->f_flags
& O_NONBLOCK
) {
1218 spin_unlock_irq(&runtime
->lock
);
1219 return result
> 0 ? result
: -EAGAIN
;
1221 init_waitqueue_entry(&wait
, current
);
1222 add_wait_queue(&runtime
->sleep
, &wait
);
1223 set_current_state(TASK_INTERRUPTIBLE
);
1224 spin_unlock_irq(&runtime
->lock
);
1225 timeout
= schedule_timeout(30 * HZ
);
1226 remove_wait_queue(&runtime
->sleep
, &wait
);
1227 if (signal_pending(current
))
1228 return result
> 0 ? result
: -ERESTARTSYS
;
1229 if (!runtime
->avail
&& !timeout
)
1230 return result
> 0 ? result
: -EIO
;
1231 spin_lock_irq(&runtime
->lock
);
1233 spin_unlock_irq(&runtime
->lock
);
1234 count1
= snd_rawmidi_kernel_write1(substream
,
1235 (unsigned char __force
*)buf
,
1238 return result
> 0 ? result
: count1
;
1241 if ((size_t)count1
< count
&& (file
->f_flags
& O_NONBLOCK
))
1245 if (file
->f_flags
& O_SYNC
) {
1246 spin_lock_irq(&runtime
->lock
);
1247 while (runtime
->avail
!= runtime
->buffer_size
) {
1249 unsigned int last_avail
= runtime
->avail
;
1250 init_waitqueue_entry(&wait
, current
);
1251 add_wait_queue(&runtime
->sleep
, &wait
);
1252 set_current_state(TASK_INTERRUPTIBLE
);
1253 spin_unlock_irq(&runtime
->lock
);
1254 timeout
= schedule_timeout(30 * HZ
);
1255 remove_wait_queue(&runtime
->sleep
, &wait
);
1256 if (signal_pending(current
))
1257 return result
> 0 ? result
: -ERESTARTSYS
;
1258 if (runtime
->avail
== last_avail
&& !timeout
)
1259 return result
> 0 ? result
: -EIO
;
1260 spin_lock_irq(&runtime
->lock
);
1262 spin_unlock_irq(&runtime
->lock
);
1267 static unsigned int snd_rawmidi_poll(struct file
*file
, poll_table
* wait
)
1269 struct snd_rawmidi_file
*rfile
;
1270 struct snd_rawmidi_runtime
*runtime
;
1273 rfile
= file
->private_data
;
1274 if (rfile
->input
!= NULL
) {
1275 runtime
= rfile
->input
->runtime
;
1276 snd_rawmidi_input_trigger(rfile
->input
, 1);
1277 poll_wait(file
, &runtime
->sleep
, wait
);
1279 if (rfile
->output
!= NULL
) {
1280 runtime
= rfile
->output
->runtime
;
1281 poll_wait(file
, &runtime
->sleep
, wait
);
1284 if (rfile
->input
!= NULL
) {
1285 if (snd_rawmidi_ready(rfile
->input
))
1286 mask
|= POLLIN
| POLLRDNORM
;
1288 if (rfile
->output
!= NULL
) {
1289 if (snd_rawmidi_ready(rfile
->output
))
1290 mask
|= POLLOUT
| POLLWRNORM
;
1297 #ifdef CONFIG_COMPAT
1298 #include "rawmidi_compat.c"
1300 #define snd_rawmidi_ioctl_compat NULL
1307 static void snd_rawmidi_proc_info_read(struct snd_info_entry
*entry
,
1308 struct snd_info_buffer
*buffer
)
1310 struct snd_rawmidi
*rmidi
;
1311 struct snd_rawmidi_substream
*substream
;
1312 struct snd_rawmidi_runtime
*runtime
;
1313 struct list_head
*list
;
1315 rmidi
= entry
->private_data
;
1316 snd_iprintf(buffer
, "%s\n\n", rmidi
->name
);
1317 down(&rmidi
->open_mutex
);
1318 if (rmidi
->info_flags
& SNDRV_RAWMIDI_INFO_OUTPUT
) {
1319 list_for_each(list
, &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
].substreams
) {
1320 substream
= list_entry(list
, struct snd_rawmidi_substream
, list
);
1323 " Tx bytes : %lu\n",
1325 (unsigned long) substream
->bytes
);
1326 if (substream
->opened
) {
1327 runtime
= substream
->runtime
;
1330 " Buffer size : %lu\n"
1332 runtime
->oss
? "OSS compatible" : "native",
1333 (unsigned long) runtime
->buffer_size
,
1334 (unsigned long) runtime
->avail
);
1338 if (rmidi
->info_flags
& SNDRV_RAWMIDI_INFO_INPUT
) {
1339 list_for_each(list
, &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
].substreams
) {
1340 substream
= list_entry(list
, struct snd_rawmidi_substream
, list
);
1343 " Rx bytes : %lu\n",
1345 (unsigned long) substream
->bytes
);
1346 if (substream
->opened
) {
1347 runtime
= substream
->runtime
;
1349 " Buffer size : %lu\n"
1351 " Overruns : %lu\n",
1352 (unsigned long) runtime
->buffer_size
,
1353 (unsigned long) runtime
->avail
,
1354 (unsigned long) runtime
->xruns
);
1358 up(&rmidi
->open_mutex
);
1362 * Register functions
1365 static struct file_operations snd_rawmidi_f_ops
=
1367 .owner
= THIS_MODULE
,
1368 .read
= snd_rawmidi_read
,
1369 .write
= snd_rawmidi_write
,
1370 .open
= snd_rawmidi_open
,
1371 .release
= snd_rawmidi_release
,
1372 .poll
= snd_rawmidi_poll
,
1373 .unlocked_ioctl
= snd_rawmidi_ioctl
,
1374 .compat_ioctl
= snd_rawmidi_ioctl_compat
,
1377 static int snd_rawmidi_alloc_substreams(struct snd_rawmidi
*rmidi
,
1378 struct snd_rawmidi_str
*stream
,
1382 struct snd_rawmidi_substream
*substream
;
1385 INIT_LIST_HEAD(&stream
->substreams
);
1386 for (idx
= 0; idx
< count
; idx
++) {
1387 substream
= kzalloc(sizeof(*substream
), GFP_KERNEL
);
1388 if (substream
== NULL
) {
1389 snd_printk(KERN_ERR
"rawmidi: cannot allocate substream\n");
1392 substream
->stream
= direction
;
1393 substream
->number
= idx
;
1394 substream
->rmidi
= rmidi
;
1395 substream
->pstr
= stream
;
1396 list_add_tail(&substream
->list
, &stream
->substreams
);
1397 stream
->substream_count
++;
1403 * snd_rawmidi_new - create a rawmidi instance
1404 * @card: the card instance
1405 * @id: the id string
1406 * @device: the device index
1407 * @output_count: the number of output streams
1408 * @input_count: the number of input streams
1409 * @rrawmidi: the pointer to store the new rawmidi instance
1411 * Creates a new rawmidi instance.
1412 * Use snd_rawmidi_set_ops() to set the operators to the new instance.
1414 * Returns zero if successful, or a negative error code on failure.
1416 int snd_rawmidi_new(struct snd_card
*card
, char *id
, int device
,
1417 int output_count
, int input_count
,
1418 struct snd_rawmidi
** rrawmidi
)
1420 struct snd_rawmidi
*rmidi
;
1422 static struct snd_device_ops ops
= {
1423 .dev_free
= snd_rawmidi_dev_free
,
1424 .dev_register
= snd_rawmidi_dev_register
,
1425 .dev_disconnect
= snd_rawmidi_dev_disconnect
,
1426 .dev_unregister
= snd_rawmidi_dev_unregister
1429 snd_assert(rrawmidi
!= NULL
, return -EINVAL
);
1431 snd_assert(card
!= NULL
, return -ENXIO
);
1432 rmidi
= kzalloc(sizeof(*rmidi
), GFP_KERNEL
);
1433 if (rmidi
== NULL
) {
1434 snd_printk(KERN_ERR
"rawmidi: cannot allocate\n");
1438 rmidi
->device
= device
;
1439 init_MUTEX(&rmidi
->open_mutex
);
1440 init_waitqueue_head(&rmidi
->open_wait
);
1442 strlcpy(rmidi
->id
, id
, sizeof(rmidi
->id
));
1443 if ((err
= snd_rawmidi_alloc_substreams(rmidi
,
1444 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
],
1445 SNDRV_RAWMIDI_STREAM_INPUT
,
1446 input_count
)) < 0) {
1447 snd_rawmidi_free(rmidi
);
1450 if ((err
= snd_rawmidi_alloc_substreams(rmidi
,
1451 &rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
],
1452 SNDRV_RAWMIDI_STREAM_OUTPUT
,
1453 output_count
)) < 0) {
1454 snd_rawmidi_free(rmidi
);
1457 if ((err
= snd_device_new(card
, SNDRV_DEV_RAWMIDI
, rmidi
, &ops
)) < 0) {
1458 snd_rawmidi_free(rmidi
);
1465 static void snd_rawmidi_free_substreams(struct snd_rawmidi_str
*stream
)
1467 struct snd_rawmidi_substream
*substream
;
1469 while (!list_empty(&stream
->substreams
)) {
1470 substream
= list_entry(stream
->substreams
.next
, struct snd_rawmidi_substream
, list
);
1471 list_del(&substream
->list
);
1476 static int snd_rawmidi_free(struct snd_rawmidi
*rmidi
)
1478 snd_assert(rmidi
!= NULL
, return -ENXIO
);
1479 snd_rawmidi_free_substreams(&rmidi
->streams
[SNDRV_RAWMIDI_STREAM_INPUT
]);
1480 snd_rawmidi_free_substreams(&rmidi
->streams
[SNDRV_RAWMIDI_STREAM_OUTPUT
]);
1481 if (rmidi
->private_free
)
1482 rmidi
->private_free(rmidi
);
1487 static int snd_rawmidi_dev_free(struct snd_device
*device
)
1489 struct snd_rawmidi
*rmidi
= device
->device_data
;
1490 return snd_rawmidi_free(rmidi
);
1493 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
1494 static void snd_rawmidi_dev_seq_free(struct snd_seq_device
*device
)
1496 struct snd_rawmidi
*rmidi
= device
->private_data
;
1497 rmidi
->seq_dev
= NULL
;
1501 static int snd_rawmidi_dev_register(struct snd_device
*device
)
1504 struct snd_info_entry
*entry
;
1506 struct snd_rawmidi
*rmidi
= device
->device_data
;
1508 if (rmidi
->device
>= SNDRV_RAWMIDI_DEVICES
)
1510 down(®ister_mutex
);
1511 if (snd_rawmidi_search(rmidi
->card
, rmidi
->device
)) {
1512 up(®ister_mutex
);
1515 list_add_tail(&rmidi
->list
, &snd_rawmidi_devices
);
1516 sprintf(name
, "midiC%iD%i", rmidi
->card
->number
, rmidi
->device
);
1517 if ((err
= snd_register_device(SNDRV_DEVICE_TYPE_RAWMIDI
,
1518 rmidi
->card
, rmidi
->device
,
1519 &snd_rawmidi_f_ops
, rmidi
, name
)) < 0) {
1520 snd_printk(KERN_ERR
"unable to register rawmidi device %i:%i\n", rmidi
->card
->number
, rmidi
->device
);
1521 list_del(&rmidi
->list
);
1522 up(®ister_mutex
);
1525 if (rmidi
->ops
&& rmidi
->ops
->dev_register
&&
1526 (err
= rmidi
->ops
->dev_register(rmidi
)) < 0) {
1527 snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI
, rmidi
->card
, rmidi
->device
);
1528 list_del(&rmidi
->list
);
1529 up(®ister_mutex
);
1532 #ifdef CONFIG_SND_OSSEMUL
1534 if ((int)rmidi
->device
== midi_map
[rmidi
->card
->number
]) {
1535 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
,
1536 rmidi
->card
, 0, &snd_rawmidi_f_ops
,
1538 snd_printk(KERN_ERR
"unable to register OSS rawmidi device %i:%i\n", rmidi
->card
->number
, 0);
1541 #ifdef SNDRV_OSS_INFO_DEV_MIDI
1542 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIDI
, rmidi
->card
->number
, rmidi
->name
);
1546 if ((int)rmidi
->device
== amidi_map
[rmidi
->card
->number
]) {
1547 if (snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
,
1548 rmidi
->card
, 1, &snd_rawmidi_f_ops
,
1550 snd_printk(KERN_ERR
"unable to register OSS rawmidi device %i:%i\n", rmidi
->card
->number
, 1);
1555 #endif /* CONFIG_SND_OSSEMUL */
1556 up(®ister_mutex
);
1557 sprintf(name
, "midi%d", rmidi
->device
);
1558 entry
= snd_info_create_card_entry(rmidi
->card
, name
, rmidi
->card
->proc_root
);
1560 entry
->private_data
= rmidi
;
1561 entry
->c
.text
.read_size
= 1024;
1562 entry
->c
.text
.read
= snd_rawmidi_proc_info_read
;
1563 if (snd_info_register(entry
) < 0) {
1564 snd_info_free_entry(entry
);
1568 rmidi
->proc_entry
= entry
;
1569 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
1570 if (!rmidi
->ops
|| !rmidi
->ops
->dev_register
) { /* own registration mechanism */
1571 if (snd_seq_device_new(rmidi
->card
, rmidi
->device
, SNDRV_SEQ_DEV_ID_MIDISYNTH
, 0, &rmidi
->seq_dev
) >= 0) {
1572 rmidi
->seq_dev
->private_data
= rmidi
;
1573 rmidi
->seq_dev
->private_free
= snd_rawmidi_dev_seq_free
;
1574 sprintf(rmidi
->seq_dev
->name
, "MIDI %d-%d", rmidi
->card
->number
, rmidi
->device
);
1575 snd_device_register(rmidi
->card
, rmidi
->seq_dev
);
1582 static int snd_rawmidi_dev_disconnect(struct snd_device
*device
)
1584 struct snd_rawmidi
*rmidi
= device
->device_data
;
1586 down(®ister_mutex
);
1587 list_del_init(&rmidi
->list
);
1588 up(®ister_mutex
);
1592 static int snd_rawmidi_dev_unregister(struct snd_device
*device
)
1594 struct snd_rawmidi
*rmidi
= device
->device_data
;
1596 snd_assert(rmidi
!= NULL
, return -ENXIO
);
1597 down(®ister_mutex
);
1598 list_del(&rmidi
->list
);
1599 if (rmidi
->proc_entry
) {
1600 snd_info_unregister(rmidi
->proc_entry
);
1601 rmidi
->proc_entry
= NULL
;
1603 #ifdef CONFIG_SND_OSSEMUL
1604 if (rmidi
->ossreg
) {
1605 if ((int)rmidi
->device
== midi_map
[rmidi
->card
->number
]) {
1606 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
, rmidi
->card
, 0);
1607 #ifdef SNDRV_OSS_INFO_DEV_MIDI
1608 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIDI
, rmidi
->card
->number
);
1611 if ((int)rmidi
->device
== amidi_map
[rmidi
->card
->number
])
1612 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIDI
, rmidi
->card
, 1);
1615 #endif /* CONFIG_SND_OSSEMUL */
1616 if (rmidi
->ops
&& rmidi
->ops
->dev_unregister
)
1617 rmidi
->ops
->dev_unregister(rmidi
);
1618 snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI
, rmidi
->card
, rmidi
->device
);
1619 up(®ister_mutex
);
1620 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
1621 if (rmidi
->seq_dev
) {
1622 snd_device_free(rmidi
->card
, rmidi
->seq_dev
);
1623 rmidi
->seq_dev
= NULL
;
1626 return snd_rawmidi_free(rmidi
);
1630 * snd_rawmidi_set_ops - set the rawmidi operators
1631 * @rmidi: the rawmidi instance
1632 * @stream: the stream direction, SNDRV_RAWMIDI_STREAM_XXX
1633 * @ops: the operator table
1635 * Sets the rawmidi operators for the given stream direction.
1637 void snd_rawmidi_set_ops(struct snd_rawmidi
*rmidi
, int stream
,
1638 struct snd_rawmidi_ops
*ops
)
1640 struct list_head
*list
;
1641 struct snd_rawmidi_substream
*substream
;
1643 list_for_each(list
, &rmidi
->streams
[stream
].substreams
) {
1644 substream
= list_entry(list
, struct snd_rawmidi_substream
, list
);
1645 substream
->ops
= ops
;
1653 static int __init
alsa_rawmidi_init(void)
1656 snd_ctl_register_ioctl(snd_rawmidi_control_ioctl
);
1657 snd_ctl_register_ioctl_compat(snd_rawmidi_control_ioctl
);
1658 #ifdef CONFIG_SND_OSSEMUL
1660 /* check device map table */
1661 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
1662 if (midi_map
[i
] < 0 || midi_map
[i
] >= SNDRV_RAWMIDI_DEVICES
) {
1663 snd_printk(KERN_ERR
"invalid midi_map[%d] = %d\n", i
, midi_map
[i
]);
1666 if (amidi_map
[i
] < 0 || amidi_map
[i
] >= SNDRV_RAWMIDI_DEVICES
) {
1667 snd_printk(KERN_ERR
"invalid amidi_map[%d] = %d\n", i
, amidi_map
[i
]);
1672 #endif /* CONFIG_SND_OSSEMUL */
1676 static void __exit
alsa_rawmidi_exit(void)
1678 snd_ctl_unregister_ioctl(snd_rawmidi_control_ioctl
);
1679 snd_ctl_unregister_ioctl_compat(snd_rawmidi_control_ioctl
);
1682 module_init(alsa_rawmidi_init
)
1683 module_exit(alsa_rawmidi_exit
)
1685 EXPORT_SYMBOL(snd_rawmidi_output_params
);
1686 EXPORT_SYMBOL(snd_rawmidi_input_params
);
1687 EXPORT_SYMBOL(snd_rawmidi_drop_output
);
1688 EXPORT_SYMBOL(snd_rawmidi_drain_output
);
1689 EXPORT_SYMBOL(snd_rawmidi_drain_input
);
1690 EXPORT_SYMBOL(snd_rawmidi_receive
);
1691 EXPORT_SYMBOL(snd_rawmidi_transmit_empty
);
1692 EXPORT_SYMBOL(snd_rawmidi_transmit_peek
);
1693 EXPORT_SYMBOL(snd_rawmidi_transmit_ack
);
1694 EXPORT_SYMBOL(snd_rawmidi_transmit
);
1695 EXPORT_SYMBOL(snd_rawmidi_new
);
1696 EXPORT_SYMBOL(snd_rawmidi_set_ops
);
1697 EXPORT_SYMBOL(snd_rawmidi_info_select
);
1698 EXPORT_SYMBOL(snd_rawmidi_kernel_open
);
1699 EXPORT_SYMBOL(snd_rawmidi_kernel_release
);
1700 EXPORT_SYMBOL(snd_rawmidi_kernel_read
);
1701 EXPORT_SYMBOL(snd_rawmidi_kernel_write
);