← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to sound/drivers/opl3/opl3_seq.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
sound/drivers/opl3/opl3_seq.c
 
1
/*
 
2
 *  Copyright (c) by Uros Bizjak <uros@kss-loka.si>
 
3
 *
 
4
 *  Midi Sequencer interface routines for OPL2/OPL3/OPL4 FM
 
5
 *
 
6
 *  OPL2/3 FM instrument loader:
 
7
 *   alsa-tools/seq/sbiload/
 
8
 *
 
9
 *   This program is free software; you can redistribute it and/or modify
 
10
 *   it under the terms of the GNU General Public License as published by
 
11
 *   the Free Software Foundation; either version 2 of the License, or
 
12
 *   (at your option) any later version.
 
13
 *
 
14
 *   This program is distributed in the hope that it will be useful,
 
15
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
 *   GNU General Public License for more details.
 
18
 *
 
19
 *   You should have received a copy of the GNU General Public License
 
20
 *   along with this program; if not, write to the Free Software
 
21
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 
22
 *
 
23
 */
 
24
 
 
25
#include "opl3_voice.h"
 
26
#include <linux/init.h>
 
27
#include <linux/moduleparam.h>
 
28
#include <linux/module.h>
 
29
#include <sound/initval.h>
 
30
 
 
31
MODULE_AUTHOR("Uros Bizjak <uros@kss-loka.si>");
 
32
MODULE_LICENSE("GPL");
 
33
MODULE_DESCRIPTION("ALSA driver for OPL3 FM synth");
 
34
 
 
35
int use_internal_drums = 0;
 
36
module_param(use_internal_drums, bool, 0444);
 
37
MODULE_PARM_DESC(use_internal_drums, "Enable internal OPL2/3 drums.");
 
38
 
 
39
int snd_opl3_synth_use_inc(struct snd_opl3 * opl3)
 
40
{
 
41
        if (!try_module_get(opl3->card->module))
 
42
                return -EFAULT;
 
43
        return 0;
 
44
 
 
45
}
 
46
 
 
47
void snd_opl3_synth_use_dec(struct snd_opl3 * opl3)
 
48
{
 
49
        module_put(opl3->card->module);
 
50
}
 
51
 
 
52
int snd_opl3_synth_setup(struct snd_opl3 * opl3)
 
53
{
 
54
        int idx;
 
55
        struct snd_hwdep *hwdep = opl3->hwdep;
 
56
 
 
57
        mutex_lock(&hwdep->open_mutex);
 
58
        if (hwdep->used) {
 
59
                mutex_unlock(&hwdep->open_mutex);
 
60
                return -EBUSY;
 
61
        }
 
62
        hwdep->used++;
 
63
        mutex_unlock(&hwdep->open_mutex);
 
64
 
 
65
        snd_opl3_reset(opl3);
 
66
 
 
67
        for (idx = 0; idx < MAX_OPL3_VOICES; idx++) {
 
68
                opl3->voices[idx].state = SNDRV_OPL3_ST_OFF;
 
69
                opl3->voices[idx].time = 0;
 
70
                opl3->voices[idx].keyon_reg = 0x00;
 
71
        }
 
72
        opl3->use_time = 0;
 
73
        opl3->connection_reg = 0x00;
 
74
        if (opl3->hardware >= OPL3_HW_OPL3) {
 
75
                /* Clear 4-op connections */
 
76
                opl3->command(opl3, OPL3_RIGHT | OPL3_REG_CONNECTION_SELECT,
 
77
                                 opl3->connection_reg);
 
78
                opl3->max_voices = MAX_OPL3_VOICES;
 
79
        }
 
80
        return 0;
 
81
}
 
82
 
 
83
void snd_opl3_synth_cleanup(struct snd_opl3 * opl3)
 
84
{
 
85
        unsigned long flags;
 
86
        struct snd_hwdep *hwdep;
 
87
 
 
88
        /* Stop system timer */
 
89
        spin_lock_irqsave(&opl3->sys_timer_lock, flags);
 
90
        if (opl3->sys_timer_status) {
 
91
                del_timer(&opl3->tlist);
 
92
                opl3->sys_timer_status = 0;
 
93
        }
 
94
        spin_unlock_irqrestore(&opl3->sys_timer_lock, flags);
 
95
 
 
96
        snd_opl3_reset(opl3);
 
97
        hwdep = opl3->hwdep;
 
98
        mutex_lock(&hwdep->open_mutex);
 
99
        hwdep->used--;
 
100
        mutex_unlock(&hwdep->open_mutex);
 
101
        wake_up(&hwdep->open_wait);
 
102
}
 
103
 
 
104
static int snd_opl3_synth_use(void *private_data, struct snd_seq_port_subscribe * info)
 
105
{
 
106
        struct snd_opl3 *opl3 = private_data;
 
107
        int err;
 
108
 
 
109
        if ((err = snd_opl3_synth_setup(opl3)) < 0)
 
110
                return err;
 
111
 
 
112
        if (use_internal_drums) {
 
113
                /* Percussion mode */
 
114
                opl3->voices[6].state = opl3->voices[7].state = 
 
115
                        opl3->voices[8].state = SNDRV_OPL3_ST_NOT_AVAIL;
 
116
                snd_opl3_load_drums(opl3);
 
117
                opl3->drum_reg = OPL3_PERCUSSION_ENABLE;
 
118
                opl3->command(opl3, OPL3_LEFT | OPL3_REG_PERCUSSION, opl3->drum_reg);
 
119
        } else {
 
120
                opl3->drum_reg = 0x00;
 
121
        }
 
122
 
 
123
        if (info->sender.client != SNDRV_SEQ_CLIENT_SYSTEM) {
 
124
                if ((err = snd_opl3_synth_use_inc(opl3)) < 0)
 
125
                        return err;
 
126
        }
 
127
        opl3->synth_mode = SNDRV_OPL3_MODE_SEQ;
 
128
        return 0;
 
129
}
 
130
 
 
131
static int snd_opl3_synth_unuse(void *private_data, struct snd_seq_port_subscribe * info)
 
132
{
 
133
        struct snd_opl3 *opl3 = private_data;
 
134
 
 
135
        snd_opl3_synth_cleanup(opl3);
 
136
 
 
137
        if (info->sender.client != SNDRV_SEQ_CLIENT_SYSTEM)
 
138
                snd_opl3_synth_use_dec(opl3);
 
139
        return 0;
 
140
}
 
141
 
 
142
/*
 
143
 * MIDI emulation operators
 
144
 */
 
145
struct snd_midi_op opl3_ops = {
 
146
        .note_on =              snd_opl3_note_on,
 
147
        .note_off =             snd_opl3_note_off,
 
148
        .key_press =            snd_opl3_key_press,
 
149
        .note_terminate =       snd_opl3_terminate_note,
 
150
        .control =              snd_opl3_control,
 
151
        .nrpn =                 snd_opl3_nrpn,
 
152
        .sysex =                snd_opl3_sysex,
 
153
};
 
154
 
 
155
static int snd_opl3_synth_event_input(struct snd_seq_event * ev, int direct,
 
156
                                      void *private_data, int atomic, int hop)
 
157
{
 
158
        struct snd_opl3 *opl3 = private_data;
 
159
 
 
160
        snd_midi_process_event(&opl3_ops, ev, opl3->chset);
 
161
        return 0;
 
162
}
 
163
 
 
164
/* ------------------------------ */
 
165
 
 
166
static void snd_opl3_synth_free_port(void *private_data)
 
167
{
 
168
        struct snd_opl3 *opl3 = private_data;
 
169
 
 
170
        snd_midi_channel_free_set(opl3->chset);
 
171
}
 
172
 
 
173
static int snd_opl3_synth_create_port(struct snd_opl3 * opl3)
 
174
{
 
175
        struct snd_seq_port_callback callbacks;
 
176
        char name[32];
 
177
        int voices, opl_ver;
 
178
 
 
179
        voices = (opl3->hardware < OPL3_HW_OPL3) ?
 
180
                MAX_OPL2_VOICES : MAX_OPL3_VOICES;
 
181
        opl3->chset = snd_midi_channel_alloc_set(16);
 
182
        if (opl3->chset == NULL)
 
183
                return -ENOMEM;
 
184
        opl3->chset->private_data = opl3;
 
185
 
 
186
        memset(&callbacks, 0, sizeof(callbacks));
 
187
        callbacks.owner = THIS_MODULE;
 
188
        callbacks.use = snd_opl3_synth_use;
 
189
        callbacks.unuse = snd_opl3_synth_unuse;
 
190
        callbacks.event_input = snd_opl3_synth_event_input;
 
191
        callbacks.private_free = snd_opl3_synth_free_port;
 
192
        callbacks.private_data = opl3;
 
193
 
 
194
        opl_ver = (opl3->hardware & OPL3_HW_MASK) >> 8;
 
195
        sprintf(name, "OPL%i FM Port", opl_ver);
 
196
 
 
197
        opl3->chset->client = opl3->seq_client;
 
198
        opl3->chset->port = snd_seq_event_port_attach(opl3->seq_client, &callbacks,
 
199
                                                      SNDRV_SEQ_PORT_CAP_WRITE |
 
200
                                                      SNDRV_SEQ_PORT_CAP_SUBS_WRITE,
 
201
                                                      SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC |
 
202
                                                      SNDRV_SEQ_PORT_TYPE_MIDI_GM |
 
203
                                                      SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE |
 
204
                                                      SNDRV_SEQ_PORT_TYPE_HARDWARE |
 
205
                                                      SNDRV_SEQ_PORT_TYPE_SYNTHESIZER,
 
206
                                                      16, voices,
 
207
                                                      name);
 
208
        if (opl3->chset->port < 0) {
 
209
                int port;
 
210
                port = opl3->chset->port;
 
211
                snd_midi_channel_free_set(opl3->chset);
 
212
                return port;
 
213
        }
 
214
        return 0;
 
215
}
 
216
 
 
217
/* ------------------------------ */
 
218
 
 
219
static int snd_opl3_seq_new_device(struct snd_seq_device *dev)
 
220
{
 
221
        struct snd_opl3 *opl3;
 
222
        int client, err;
 
223
        char name[32];
 
224
        int opl_ver;
 
225
 
 
226
        opl3 = *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
 
227
        if (opl3 == NULL)
 
228
                return -EINVAL;
 
229
 
 
230
        spin_lock_init(&opl3->voice_lock);
 
231
 
 
232
        opl3->seq_client = -1;
 
233
 
 
234
        /* allocate new client */
 
235
        opl_ver = (opl3->hardware & OPL3_HW_MASK) >> 8;
 
236
        sprintf(name, "OPL%i FM synth", opl_ver);
 
237
        client = opl3->seq_client =
 
238
                snd_seq_create_kernel_client(opl3->card, opl3->seq_dev_num,
 
239
                                             name);
 
240
        if (client < 0)
 
241
                return client;
 
242
 
 
243
        if ((err = snd_opl3_synth_create_port(opl3)) < 0) {
 
244
                snd_seq_delete_kernel_client(client);
 
245
                opl3->seq_client = -1;
 
246
                return err;
 
247
        }
 
248
 
 
249
        /* setup system timer */
 
250
        init_timer(&opl3->tlist);
 
251
        opl3->tlist.function = snd_opl3_timer_func;
 
252
        opl3->tlist.data = (unsigned long) opl3;
 
253
        spin_lock_init(&opl3->sys_timer_lock);
 
254
        opl3->sys_timer_status = 0;
 
255
 
 
256
#ifdef CONFIG_SND_SEQUENCER_OSS
 
257
        snd_opl3_init_seq_oss(opl3, name);
 
258
#endif
 
259
        return 0;
 
260
}
 
261
 
 
262
static int snd_opl3_seq_delete_device(struct snd_seq_device *dev)
 
263
{
 
264
        struct snd_opl3 *opl3;
 
265
 
 
266
        opl3 = *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
 
267
        if (opl3 == NULL)
 
268
                return -EINVAL;
 
269
 
 
270
#ifdef CONFIG_SND_SEQUENCER_OSS
 
271
        snd_opl3_free_seq_oss(opl3);
 
272
#endif
 
273
        if (opl3->seq_client >= 0) {
 
274
                snd_seq_delete_kernel_client(opl3->seq_client);
 
275
                opl3->seq_client = -1;
 
276
        }
 
277
        return 0;
 
278
}
 
279
 
 
280
static int __init alsa_opl3_seq_init(void)
 
281
{
 
282
        static struct snd_seq_dev_ops ops =
 
283
        {
 
284
                snd_opl3_seq_new_device,
 
285
                snd_opl3_seq_delete_device
 
286
        };
 
287
 
 
288
        return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_OPL3, &ops,
 
289
                                              sizeof(struct snd_opl3 *));
 
290
}
 
291
 
 
292
static void __exit alsa_opl3_seq_exit(void)
 
293
{
 
294
        snd_seq_device_unregister_driver(SNDRV_SEQ_DEV_ID_OPL3);
 
295
}
 
296
 
 
297
module_init(alsa_opl3_seq_init)
 
298
module_exit(alsa_opl3_seq_exit)