← Back to branch summary

~hui.wang/alsa-driver/tiwai-trunk-fgit

« back to all changes in this revision

Viewing changes to drivers/virmidi.c

  • Committer: Hui Wang
  • Date: 2018-06-07 01:04:04 UTC
  • Revision ID: git-v1:baf13208df10376d9e4588ad3524aeb3c9973bdf
sync the alsa hda driver from Takashi's tree

Signed-off-by: Hui Wang <hui.wang@canonical.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/virmidi.c
 
1
/*
 
2
 *  Dummy soundcard for virtual rawmidi devices
 
3
 *
 
4
 *  Copyright (c) 2000 by Takashi Iwai <tiwai@suse.de>
 
5
 *
 
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.
 
10
 *
 
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.
 
15
 *
 
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
 
19
 *
 
20
 */
 
21
 
 
22
/*
 
23
 * VIRTUAL RAW MIDI DEVICE CARDS
 
24
 *
 
25
 * This dummy card contains up to 4 virtual rawmidi devices.
 
26
 * They are not real rawmidi devices but just associated with sequencer
 
27
 * clients, so that any input/output sources can be connected as a raw
 
28
 * MIDI device arbitrary.
 
29
 * Also, multiple access is allowed to a single rawmidi device.
 
30
 *
 
31
 * Typical usage is like following:
 
32
 * - Load snd-virmidi module.
 
33
 *      # modprobe snd-virmidi index=2
 
34
 *   Then, sequencer clients 72:0 to 75:0 will be created, which are
 
35
 *   mapped from /dev/snd/midiC1D0 to /dev/snd/midiC1D3, respectively.
 
36
 *
 
37
 * - Connect input/output via aconnect.
 
38
 *      % aconnect 64:0 72:0    # keyboard input redirection 64:0 -> 72:0
 
39
 *      % aconnect 72:0 65:0    # output device redirection 72:0 -> 65:0
 
40
 *
 
41
 * - Run application using a midi device (eg. /dev/snd/midiC1D0)
 
42
 */
 
43
 
 
44
#include <linux/init.h>
 
45
#include <linux/wait.h>
 
46
#include <linux/err.h>
 
47
#include <linux/platform_device.h>
 
48
#include <linux/module.h>
 
49
#include <sound/core.h>
 
50
#include <sound/seq_kernel.h>
 
51
#include <sound/seq_virmidi.h>
 
52
#include <sound/initval.h>
 
53
 
 
54
/* hack: OSS defines midi_devs, so undefine it (versioned symbols) */
 
55
#undef midi_devs
 
56
 
 
57
MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
 
58
MODULE_DESCRIPTION("Dummy soundcard for virtual rawmidi devices");
 
59
MODULE_LICENSE("GPL");
 
60
MODULE_SUPPORTED_DEVICE("{{ALSA,Virtual rawmidi device}}");
 
61
 
 
62
#define MAX_MIDI_DEVICES        4
 
63
 
 
64
static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 
65
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 
66
static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0};
 
67
static int midi_devs[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 4};
 
68
 
 
69
module_param_array(index, int, NULL, 0444);
 
70
MODULE_PARM_DESC(index, "Index value for virmidi soundcard.");
 
71
module_param_array(id, charp, NULL, 0444);
 
72
MODULE_PARM_DESC(id, "ID string for virmidi soundcard.");
 
73
module_param_array(enable, bool, NULL, 0444);
 
74
MODULE_PARM_DESC(enable, "Enable this soundcard.");
 
75
module_param_array(midi_devs, int, NULL, 0444);
 
76
MODULE_PARM_DESC(midi_devs, "MIDI devices # (1-4)");
 
77
 
 
78
struct snd_card_virmidi {
 
79
        struct snd_card *card;
 
80
        struct snd_rawmidi *midi[MAX_MIDI_DEVICES];
 
81
};
 
82
 
 
83
static struct platform_device *devices[SNDRV_CARDS];
 
84
 
 
85
 
 
86
static int snd_virmidi_probe(struct platform_device *devptr)
 
87
{
 
88
        struct snd_card *card;
 
89
        struct snd_card_virmidi *vmidi;
 
90
        int idx, err;
 
91
        int dev = devptr->id;
 
92
 
 
93
        err = snd_card_new(&devptr->dev, index[dev], id[dev], THIS_MODULE,
 
94
                           sizeof(struct snd_card_virmidi), &card);
 
95
        if (err < 0)
 
96
                return err;
 
97
        vmidi = card->private_data;
 
98
        vmidi->card = card;
 
99
 
 
100
        if (midi_devs[dev] > MAX_MIDI_DEVICES) {
 
101
                snd_printk(KERN_WARNING
 
102
                           "too much midi devices for virmidi %d: force to use %d\n",
 
103
                           dev, MAX_MIDI_DEVICES);
 
104
                midi_devs[dev] = MAX_MIDI_DEVICES;
 
105
        }
 
106
        for (idx = 0; idx < midi_devs[dev]; idx++) {
 
107
                struct snd_rawmidi *rmidi;
 
108
                struct snd_virmidi_dev *rdev;
 
109
 
 
110
                err = snd_virmidi_new(card, idx, &rmidi);
 
111
                if (err < 0)
 
112
                        goto __nodev;
 
113
                rdev = rmidi->private_data;
 
114
                vmidi->midi[idx] = rmidi;
 
115
                strcpy(rmidi->name, "Virtual Raw MIDI");
 
116
                rdev->seq_mode = SNDRV_VIRMIDI_SEQ_DISPATCH;
 
117
        }
 
118
 
 
119
        strcpy(card->driver, "VirMIDI");
 
120
        strcpy(card->shortname, "VirMIDI");
 
121
        sprintf(card->longname, "Virtual MIDI Card %i", dev + 1);
 
122
 
 
123
        err = snd_card_register(card);
 
124
        if (!err) {
 
125
                platform_set_drvdata(devptr, card);
 
126
                return 0;
 
127
        }
 
128
__nodev:
 
129
        snd_card_free(card);
 
130
        return err;
 
131
}
 
132
 
 
133
static int snd_virmidi_remove(struct platform_device *devptr)
 
134
{
 
135
        snd_card_free(platform_get_drvdata(devptr));
 
136
        return 0;
 
137
}
 
138
 
 
139
#define SND_VIRMIDI_DRIVER      "snd_virmidi"
 
140
 
 
141
static struct platform_driver snd_virmidi_driver = {
 
142
        .probe          = snd_virmidi_probe,
 
143
        .remove         = snd_virmidi_remove,
 
144
        .driver         = {
 
145
                .name   = SND_VIRMIDI_DRIVER,
 
146
        },
 
147
};
 
148
 
 
149
static void snd_virmidi_unregister_all(void)
 
150
{
 
151
        int i;
 
152
 
 
153
        for (i = 0; i < ARRAY_SIZE(devices); ++i)
 
154
                platform_device_unregister(devices[i]);
 
155
        platform_driver_unregister(&snd_virmidi_driver);
 
156
}
 
157
 
 
158
static int __init alsa_card_virmidi_init(void)
 
159
{
 
160
        int i, cards, err;
 
161
 
 
162
        err = platform_driver_register(&snd_virmidi_driver);
 
163
        if (err < 0)
 
164
                return err;
 
165
 
 
166
        cards = 0;
 
167
        for (i = 0; i < SNDRV_CARDS; i++) {
 
168
                struct platform_device *device;
 
169
 
 
170
                if (!enable[i])
 
171
                        continue;
 
172
                device = platform_device_register_simple(SND_VIRMIDI_DRIVER,
 
173
                                                         i, NULL, 0);
 
174
                if (IS_ERR(device))
 
175
                        continue;
 
176
                if (!platform_get_drvdata(device)) {
 
177
                        platform_device_unregister(device);
 
178
                        continue;
 
179
                }
 
180
                devices[i] = device;
 
181
                cards++;
 
182
        }
 
183
        if (!cards) {
 
184
#ifdef MODULE
 
185
                printk(KERN_ERR "Card-VirMIDI soundcard not found or device busy\n");
 
186
#endif
 
187
                snd_virmidi_unregister_all();
 
188
                return -ENODEV;
 
189
        }
 
190
        return 0;
 
191
}
 
192
 
 
193
static void __exit alsa_card_virmidi_exit(void)
 
194
{
 
195
        snd_virmidi_unregister_all();
 
196
}
 
197
 
 
198
module_init(alsa_card_virmidi_init)
 
199
module_exit(alsa_card_virmidi_exit)