URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [synth/] [emux/] [emux_seq.c] - Blame information for rev 3

Details | Compare with Previous | View Log


/*
 *  Midi Sequencer interface routines.
 *
 *  Copyright (C) 1999 Steve Ratcliffe
 *  Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */
 
#include "emux_voice.h"
#include <linux/slab.h>
 
 
/* Prototypes for static functions */
static void free_port(void *private);
static void snd_emux_init_port(struct snd_emux_port *p);
static int snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info);
static int snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info);
 
/*
 * MIDI emulation operators
 */
static struct snd_midi_op emux_ops = {
        snd_emux_note_on,
        snd_emux_note_off,
        snd_emux_key_press,
        snd_emux_terminate_note,
        snd_emux_control,
        snd_emux_nrpn,
        snd_emux_sysex,
};
 
 
/*
 * number of MIDI channels
 */
#define MIDI_CHANNELS           16
 
/*
 * type flags for MIDI sequencer port
 */
#define DEFAULT_MIDI_TYPE       (SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |\
                                 SNDRV_SEQ_PORT_TYPE_MIDI_GM |\
                                 SNDRV_SEQ_PORT_TYPE_MIDI_GS |\
                                 SNDRV_SEQ_PORT_TYPE_MIDI_XG |\
                                 SNDRV_SEQ_PORT_TYPE_HARDWARE |\
                                 SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)
 
/*
 * Initialise the EMUX Synth by creating a client and registering
 * a series of ports.
 * Each of the ports will contain the 16 midi channels.  Applications
 * can connect to these ports to play midi data.
 */
int
snd_emux_init_seq(struct snd_emux *emu, struct snd_card *card, int index)
{
        int  i;
        struct snd_seq_port_callback pinfo;
        char tmpname[64];
 
        emu->client = snd_seq_create_kernel_client(card, index,
                                                   "%s WaveTable", emu->name);
        if (emu->client < 0) {
                snd_printk("can't create client\n");
                return -ENODEV;
        }
 
        if (emu->num_ports < 0) {
                snd_printk("seqports must be greater than zero\n");
                emu->num_ports = 1;
        } else if (emu->num_ports >= SNDRV_EMUX_MAX_PORTS) {
                snd_printk("too many ports."
                           "limited max. ports %d\n", SNDRV_EMUX_MAX_PORTS);
                emu->num_ports = SNDRV_EMUX_MAX_PORTS;
        }
 
        memset(&pinfo, 0, sizeof(pinfo));
        pinfo.owner = THIS_MODULE;
        pinfo.use = snd_emux_use;
        pinfo.unuse = snd_emux_unuse;
        pinfo.event_input = snd_emux_event_input;
 
        for (i = 0; i < emu->num_ports; i++) {
                struct snd_emux_port *p;
 
                sprintf(tmpname, "%s Port %d", emu->name, i);
                p = snd_emux_create_port(emu, tmpname, MIDI_CHANNELS,
                                         0, &pinfo);
                if (p == NULL) {
                        snd_printk("can't create port\n");
                        return -ENOMEM;
                }
 
                p->port_mode =  SNDRV_EMUX_PORT_MODE_MIDI;
                snd_emux_init_port(p);
                emu->ports[i] = p->chset.port;
                emu->portptrs[i] = p;
        }
 
        return 0;
}
 
 
/*
 * Detach from the ports that were set up for this synthesizer and
 * destroy the kernel client.
 */
void
snd_emux_detach_seq(struct snd_emux *emu)
{
        if (emu->voices)
                snd_emux_terminate_all(emu);
 
        mutex_lock(&emu->register_mutex);
        if (emu->client >= 0) {
                snd_seq_delete_kernel_client(emu->client);
                emu->client = -1;
        }
        mutex_unlock(&emu->register_mutex);
}
 
 
/*
 * create a sequencer port and channel_set
 */
 
struct snd_emux_port *
snd_emux_create_port(struct snd_emux *emu, char *name,
                     int max_channels, int oss_port,
                     struct snd_seq_port_callback *callback)
{
        struct snd_emux_port *p;
        int i, type, cap;
 
        /* Allocate structures for this channel */
        if ((p = kzalloc(sizeof(*p), GFP_KERNEL)) == NULL) {
                snd_printk("no memory\n");
                return NULL;
        }
        p->chset.channels = kcalloc(max_channels, sizeof(struct snd_midi_channel), GFP_KERNEL);
        if (p->chset.channels == NULL) {
                snd_printk("no memory\n");
                kfree(p);
                return NULL;
        }
        for (i = 0; i < max_channels; i++)
                p->chset.channels[i].number = i;
        p->chset.private_data = p;
        p->chset.max_channels = max_channels;
        p->emu = emu;
        p->chset.client = emu->client;
#ifdef SNDRV_EMUX_USE_RAW_EFFECT
        snd_emux_create_effect(p);
#endif
        callback->private_free = free_port;
        callback->private_data = p;
 
        cap = SNDRV_SEQ_PORT_CAP_WRITE;
        if (oss_port) {
                type = SNDRV_SEQ_PORT_TYPE_SPECIFIC;
        } else {
                type = DEFAULT_MIDI_TYPE;
                cap |= SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
        }
 
        p->chset.port = snd_seq_event_port_attach(emu->client, callback,
                                                  cap, type, max_channels,
                                                  emu->max_voices, name);
 
        return p;
}
 
 
/*
 * release memory block for port
 */
static void
free_port(void *private_data)
{
        struct snd_emux_port *p;
 
        p = private_data;
        if (p) {
#ifdef SNDRV_EMUX_USE_RAW_EFFECT
                snd_emux_delete_effect(p);
#endif
                kfree(p->chset.channels);
                kfree(p);
        }
}
 
 
#define DEFAULT_DRUM_FLAGS      (1<<9)
 
/*
 * initialize the port specific parameters
 */
static void
snd_emux_init_port(struct snd_emux_port *p)
{
        p->drum_flags = DEFAULT_DRUM_FLAGS;
        p->volume_atten = 0;
 
        snd_emux_reset_port(p);
}
 
 
/*
 * reset port
 */
void
snd_emux_reset_port(struct snd_emux_port *port)
{
        int i;
 
        /* stop all sounds */
        snd_emux_sounds_off_all(port);
 
        snd_midi_channel_set_clear(&port->chset);
 
#ifdef SNDRV_EMUX_USE_RAW_EFFECT
        snd_emux_clear_effect(port);
#endif
 
        /* set port specific control parameters */
        port->ctrls[EMUX_MD_DEF_BANK] = 0;
        port->ctrls[EMUX_MD_DEF_DRUM] = 0;
        port->ctrls[EMUX_MD_REALTIME_PAN] = 1;
 
        for (i = 0; i < port->chset.max_channels; i++) {
                struct snd_midi_channel *chan = port->chset.channels + i;
                chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0;
        }
}
 
 
/*
 * input sequencer event
 */
int
snd_emux_event_input(struct snd_seq_event *ev, int direct, void *private_data,
                     int atomic, int hop)
{
        struct snd_emux_port *port;
 
        port = private_data;
        snd_assert(port != NULL && ev != NULL, return -EINVAL);
 
        snd_midi_process_event(&emux_ops, ev, &port->chset);
 
        return 0;
}
 
 
/*
 * increment usage count
 */
int
snd_emux_inc_count(struct snd_emux *emu)
{
        emu->used++;
        if (!try_module_get(emu->ops.owner))
                goto __error;
        if (!try_module_get(emu->card->module)) {
                module_put(emu->ops.owner);
              __error:
                emu->used--;
                return 0;
        }
        return 1;
}
 
 
/*
 * decrease usage count
 */
void
snd_emux_dec_count(struct snd_emux *emu)
{
        module_put(emu->card->module);
        emu->used--;
        if (emu->used <= 0)
                snd_emux_terminate_all(emu);
        module_put(emu->ops.owner);
}
 
 
/*
 * Routine that is called upon a first use of a particular port
 */
static int
snd_emux_use(void *private_data, struct snd_seq_port_subscribe *info)
{
        struct snd_emux_port *p;
        struct snd_emux *emu;
 
        p = private_data;
        snd_assert(p != NULL, return -EINVAL);
        emu = p->emu;
        snd_assert(emu != NULL, return -EINVAL);
 
        mutex_lock(&emu->register_mutex);
        snd_emux_init_port(p);
        snd_emux_inc_count(emu);
        mutex_unlock(&emu->register_mutex);
        return 0;
}
 
/*
 * Routine that is called upon the last unuse() of a particular port.
 */
static int
snd_emux_unuse(void *private_data, struct snd_seq_port_subscribe *info)
{
        struct snd_emux_port *p;
        struct snd_emux *emu;
 
        p = private_data;
        snd_assert(p != NULL, return -EINVAL);
        emu = p->emu;
        snd_assert(emu != NULL, return -EINVAL);
 
        mutex_lock(&emu->register_mutex);
        snd_emux_sounds_off_all(p);
        snd_emux_dec_count(emu);
        mutex_unlock(&emu->register_mutex);
        return 0;
}
 
 
/*
 * attach virtual rawmidi devices
 */
int snd_emux_init_virmidi(struct snd_emux *emu, struct snd_card *card)
{
        int i;
 
        emu->vmidi = NULL;
        if (emu->midi_ports <= 0)
                return 0;
 
        emu->vmidi = kcalloc(emu->midi_ports, sizeof(struct snd_rawmidi *), GFP_KERNEL);
        if (emu->vmidi == NULL)
                return -ENOMEM;
 
        for (i = 0; i < emu->midi_ports; i++) {
                struct snd_rawmidi *rmidi;
                struct snd_virmidi_dev *rdev;
                if (snd_virmidi_new(card, emu->midi_devidx + i, &rmidi) < 0)
                        goto __error;
                rdev = rmidi->private_data;
                sprintf(rmidi->name, "%s Synth MIDI", emu->name);
                rdev->seq_mode = SNDRV_VIRMIDI_SEQ_ATTACH;
                rdev->client = emu->client;
                rdev->port = emu->ports[i];
                if (snd_device_register(card, rmidi) < 0) {
                        snd_device_free(card, rmidi);
                        goto __error;
                }
                emu->vmidi[i] = rmidi;
                //snd_printk("virmidi %d ok\n", i);
        }
        return 0;
 
__error:
        //snd_printk("error init..\n");
        snd_emux_delete_virmidi(emu);
        return -ENOMEM;
}
 
int snd_emux_delete_virmidi(struct snd_emux *emu)
{
        int i;
 
        if (emu->vmidi == NULL)
                return 0;
 
        for (i = 0; i < emu->midi_ports; i++) {
                if (emu->vmidi[i])
                        snd_device_free(emu->card, emu->vmidi[i]);
        }
        kfree(emu->vmidi);
        emu->vmidi = NULL;
        return 0;
}

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [sound/] [synth/] [emux/] [emux_seq.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* Midi Sequencer interface routines.`
3			`*`
4			`* Copyright (C) 1999 Steve Ratcliffe`
5			`* Copyright (c) 1999-2000 Takashi Iwai <tiwai@suse.de>`
6			`*`
7			`* This program is free software; you can redistribute it and/or modify`
8			`* it under the terms of the GNU General Public License as published by`
9			`* the Free Software Foundation; either version 2 of the License, or`
10			`* (at your option) any later version.`
11			`*`
12			`* This program is distributed in the hope that it will be useful,`
13			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
14			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15			`* GNU General Public License for more details.`
16			`*`
17			`* You should have received a copy of the GNU General Public License`
18			`* along with this program; if not, write to the Free Software`
19			`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
20			`*/`
21
22			`#include "emux_voice.h"`
23			`#include <linux/slab.h>`
24
25
26			`/* Prototypes for static functions */`
27			`static void free_port(void *private);`
28			`static void snd_emux_init_port(struct snd_emux_port *p);`
29			`static int snd_emux_use(void private_data, struct snd_seq_port_subscribe info);`
30			`static int snd_emux_unuse(void private_data, struct snd_seq_port_subscribe info);`
31
32			`/*`
33			`* MIDI emulation operators`
34			`*/`
35			`static struct snd_midi_op emux_ops = {`
36			`snd_emux_note_on,`
37			`snd_emux_note_off,`
38			`snd_emux_key_press,`
39			`snd_emux_terminate_note,`
40			`snd_emux_control,`
41			`snd_emux_nrpn,`
42			`snd_emux_sysex,`
43			`};`
44
45
46			`/*`
47			`* number of MIDI channels`
48			`*/`
49			`#define MIDI_CHANNELS 16`
50
51			`/*`
52			`* type flags for MIDI sequencer port`
53			`*/`
54			`#define DEFAULT_MIDI_TYPE (SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC \|\`
55			`SNDRV_SEQ_PORT_TYPE_MIDI_GM \|\`
56			`SNDRV_SEQ_PORT_TYPE_MIDI_GS \|\`
57			`SNDRV_SEQ_PORT_TYPE_MIDI_XG \|\`
58			`SNDRV_SEQ_PORT_TYPE_HARDWARE \|\`
59			`SNDRV_SEQ_PORT_TYPE_SYNTHESIZER)`
60
61			`/*`
62			`* Initialise the EMUX Synth by creating a client and registering`
63			`* a series of ports.`
64			`* Each of the ports will contain the 16 midi channels. Applications`
65			`* can connect to these ports to play midi data.`
66			`*/`
67			`int`
68			`snd_emux_init_seq(struct snd_emux emu, struct snd_card card, int index)`
69			`{`
70			`int i;`
71			`struct snd_seq_port_callback pinfo;`
72			`char tmpname[64];`
73
74			`emu->client = snd_seq_create_kernel_client(card, index,`
75			`"%s WaveTable", emu->name);`
76			`if (emu->client < 0) {`
77			`snd_printk("can't create client\n");`
78			`return -ENODEV;`
79			`}`
80
81			`if (emu->num_ports < 0) {`
82			`snd_printk("seqports must be greater than zero\n");`
83			`emu->num_ports = 1;`
84			`} else if (emu->num_ports >= SNDRV_EMUX_MAX_PORTS) {`
85			`snd_printk("too many ports."`
86			`"limited max. ports %d\n", SNDRV_EMUX_MAX_PORTS);`
87			`emu->num_ports = SNDRV_EMUX_MAX_PORTS;`
88			`}`
89
90			`memset(&pinfo, 0, sizeof(pinfo));`
91			`pinfo.owner = THIS_MODULE;`
92			`pinfo.use = snd_emux_use;`
93			`pinfo.unuse = snd_emux_unuse;`
94			`pinfo.event_input = snd_emux_event_input;`
95
96			`for (i = 0; i < emu->num_ports; i++) {`
97			`struct snd_emux_port *p;`
98
99			`sprintf(tmpname, "%s Port %d", emu->name, i);`
100			`p = snd_emux_create_port(emu, tmpname, MIDI_CHANNELS,`
101			`0, &pinfo);`
102			`if (p == NULL) {`
103			`snd_printk("can't create port\n");`
104			`return -ENOMEM;`
105			`}`
106
107			`p->port_mode = SNDRV_EMUX_PORT_MODE_MIDI;`
108			`snd_emux_init_port(p);`
109			`emu->ports[i] = p->chset.port;`
110			`emu->portptrs[i] = p;`
111			`}`
112
113			`return 0;`
114			`}`
115
116
117			`/*`
118			`* Detach from the ports that were set up for this synthesizer and`
119			`* destroy the kernel client.`
120			`*/`
121			`void`
122			`snd_emux_detach_seq(struct snd_emux *emu)`
123			`{`
124			`if (emu->voices)`
125			`snd_emux_terminate_all(emu);`
126
127			`mutex_lock(&emu->register_mutex);`
128			`if (emu->client >= 0) {`
129			`snd_seq_delete_kernel_client(emu->client);`
130			`emu->client = -1;`
131			`}`
132			`mutex_unlock(&emu->register_mutex);`
133			`}`
134
135
136			`/*`
137			`* create a sequencer port and channel_set`
138			`*/`
139
140			`struct snd_emux_port *`
141			`snd_emux_create_port(struct snd_emux emu, char name,`
142			`int max_channels, int oss_port,`
143			`struct snd_seq_port_callback *callback)`
144			`{`
145			`struct snd_emux_port *p;`
146			`int i, type, cap;`
147
148			`/* Allocate structures for this channel */`
149			`if ((p = kzalloc(sizeof(*p), GFP_KERNEL)) == NULL) {`
150			`snd_printk("no memory\n");`
151			`return NULL;`
152			`}`
153			`p->chset.channels = kcalloc(max_channels, sizeof(struct snd_midi_channel), GFP_KERNEL);`
154			`if (p->chset.channels == NULL) {`
155			`snd_printk("no memory\n");`
156			`kfree(p);`
157			`return NULL;`
158			`}`
159			`for (i = 0; i < max_channels; i++)`
160			`p->chset.channels[i].number = i;`
161			`p->chset.private_data = p;`
162			`p->chset.max_channels = max_channels;`
163			`p->emu = emu;`
164			`p->chset.client = emu->client;`
165			`#ifdef SNDRV_EMUX_USE_RAW_EFFECT`
166			`snd_emux_create_effect(p);`
167			`#endif`
168			`callback->private_free = free_port;`
169			`callback->private_data = p;`
170
171			`cap = SNDRV_SEQ_PORT_CAP_WRITE;`
172			`if (oss_port) {`
173			`type = SNDRV_SEQ_PORT_TYPE_SPECIFIC;`
174			`} else {`
175			`type = DEFAULT_MIDI_TYPE;`
176			`cap \|= SNDRV_SEQ_PORT_CAP_SUBS_WRITE;`
177			`}`
178
179			`p->chset.port = snd_seq_event_port_attach(emu->client, callback,`
180			`cap, type, max_channels,`
181			`emu->max_voices, name);`
182
183			`return p;`
184			`}`
185
186
187			`/*`
188			`* release memory block for port`
189			`*/`
190			`static void`
191			`free_port(void *private_data)`
192			`{`
193			`struct snd_emux_port *p;`
194
195			`p = private_data;`
196			`if (p) {`
197			`#ifdef SNDRV_EMUX_USE_RAW_EFFECT`
198			`snd_emux_delete_effect(p);`
199			`#endif`
200			`kfree(p->chset.channels);`
201			`kfree(p);`
202			`}`
203			`}`
204
205
206			`#define DEFAULT_DRUM_FLAGS (1<<9)`
207
208			`/*`
209			`* initialize the port specific parameters`
210			`*/`
211			`static void`
212			`snd_emux_init_port(struct snd_emux_port *p)`
213			`{`
214			`p->drum_flags = DEFAULT_DRUM_FLAGS;`
215			`p->volume_atten = 0;`
216
217			`snd_emux_reset_port(p);`
218			`}`
219
220
221			`/*`
222			`* reset port`
223			`*/`
224			`void`
225			`snd_emux_reset_port(struct snd_emux_port *port)`
226			`{`
227			`int i;`
228
229			`/* stop all sounds */`
230			`snd_emux_sounds_off_all(port);`
231
232			`snd_midi_channel_set_clear(&port->chset);`
233
234			`#ifdef SNDRV_EMUX_USE_RAW_EFFECT`
235			`snd_emux_clear_effect(port);`
236			`#endif`
237
238			`/* set port specific control parameters */`
239			`port->ctrls[EMUX_MD_DEF_BANK] = 0;`
240			`port->ctrls[EMUX_MD_DEF_DRUM] = 0;`
241			`port->ctrls[EMUX_MD_REALTIME_PAN] = 1;`
242
243			`for (i = 0; i < port->chset.max_channels; i++) {`
244			`struct snd_midi_channel *chan = port->chset.channels + i;`
245			`chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0;`
246			`}`
247			`}`
248
249
250			`/*`
251			`* input sequencer event`
252			`*/`
253			`int`
254			`snd_emux_event_input(struct snd_seq_event ev, int direct, void private_data,`
255			`int atomic, int hop)`
256			`{`
257			`struct snd_emux_port *port;`
258
259			`port = private_data;`
260			`snd_assert(port != NULL && ev != NULL, return -EINVAL);`
261
262			`snd_midi_process_event(&emux_ops, ev, &port->chset);`
263
264			`return 0;`
265			`}`
266
267
268			`/*`
269			`* increment usage count`
270			`*/`
271			`int`
272			`snd_emux_inc_count(struct snd_emux *emu)`
273			`{`
274			`emu->used++;`
275			`if (!try_module_get(emu->ops.owner))`
276			`goto __error;`
277			`if (!try_module_get(emu->card->module)) {`
278			`module_put(emu->ops.owner);`
279			`__error:`
280			`emu->used--;`
281			`return 0;`
282			`}`
283			`return 1;`
284			`}`
285
286
287			`/*`
288			`* decrease usage count`
289			`*/`
290			`void`
291			`snd_emux_dec_count(struct snd_emux *emu)`
292			`{`
293			`module_put(emu->card->module);`
294			`emu->used--;`
295			`if (emu->used <= 0)`
296			`snd_emux_terminate_all(emu);`
297			`module_put(emu->ops.owner);`
298			`}`
299
300
301			`/*`
302			`* Routine that is called upon a first use of a particular port`
303			`*/`
304			`static int`
305			`snd_emux_use(void private_data, struct snd_seq_port_subscribe info)`
306			`{`
307			`struct snd_emux_port *p;`
308			`struct snd_emux *emu;`
309
310			`p = private_data;`
311			`snd_assert(p != NULL, return -EINVAL);`
312			`emu = p->emu;`
313			`snd_assert(emu != NULL, return -EINVAL);`
314
315			`mutex_lock(&emu->register_mutex);`
316			`snd_emux_init_port(p);`
317			`snd_emux_inc_count(emu);`
318			`mutex_unlock(&emu->register_mutex);`
319			`return 0;`
320			`}`
321
322			`/*`
323			`* Routine that is called upon the last unuse() of a particular port.`
324			`*/`
325			`static int`
326			`snd_emux_unuse(void private_data, struct snd_seq_port_subscribe info)`
327			`{`
328			`struct snd_emux_port *p;`
329			`struct snd_emux *emu;`
330
331			`p = private_data;`
332			`snd_assert(p != NULL, return -EINVAL);`
333			`emu = p->emu;`
334			`snd_assert(emu != NULL, return -EINVAL);`
335
336			`mutex_lock(&emu->register_mutex);`
337			`snd_emux_sounds_off_all(p);`
338			`snd_emux_dec_count(emu);`
339			`mutex_unlock(&emu->register_mutex);`
340			`return 0;`
341			`}`
342
343
344			`/*`
345			`* attach virtual rawmidi devices`
346			`*/`
347			`int snd_emux_init_virmidi(struct snd_emux emu, struct snd_card card)`
348			`{`
349			`int i;`
350
351			`emu->vmidi = NULL;`
352			`if (emu->midi_ports <= 0)`
353			`return 0;`
354
355			`emu->vmidi = kcalloc(emu->midi_ports, sizeof(struct snd_rawmidi *), GFP_KERNEL);`
356			`if (emu->vmidi == NULL)`
357			`return -ENOMEM;`
358
359			`for (i = 0; i < emu->midi_ports; i++) {`
360			`struct snd_rawmidi *rmidi;`
361			`struct snd_virmidi_dev *rdev;`
362			`if (snd_virmidi_new(card, emu->midi_devidx + i, &rmidi) < 0)`
363			`goto __error;`
364			`rdev = rmidi->private_data;`
365			`sprintf(rmidi->name, "%s Synth MIDI", emu->name);`
366			`rdev->seq_mode = SNDRV_VIRMIDI_SEQ_ATTACH;`
367			`rdev->client = emu->client;`
368			`rdev->port = emu->ports[i];`
369			`if (snd_device_register(card, rmidi) < 0) {`
370			`snd_device_free(card, rmidi);`
371			`goto __error;`
372			`}`
373			`emu->vmidi[i] = rmidi;`
374			`//snd_printk("virmidi %d ok\n", i);`
375			`}`
376			`return 0;`
377
378			`__error:`
379			`//snd_printk("error init..\n");`
380			`snd_emux_delete_virmidi(emu);`
381			`return -ENOMEM;`
382			`}`
383
384			`int snd_emux_delete_virmidi(struct snd_emux *emu)`
385			`{`
386			`int i;`
387
388			`if (emu->vmidi == NULL)`
389			`return 0;`
390
391			`for (i = 0; i < emu->midi_ports; i++) {`
392			`if (emu->vmidi[i])`
393			`snd_device_free(emu->card, emu->vmidi[i]);`
394			`}`
395			`kfree(emu->vmidi);`
396			`emu->vmidi = NULL;`
397			`return 0;`
398			`}`