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 bool 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_probe(struct device *_dev) 220 { 221 struct snd_seq_device *dev = to_seq_dev(_dev); 222 struct snd_opl3 *opl3; 223 int client, err; 224 char name[32]; 225 int opl_ver; 226 227 opl3 = *(struct snd_opl3 **)SNDRV_SEQ_DEVICE_ARGPTR(dev); 228 if (opl3 == NULL) 229 return -EINVAL; 230 231 spin_lock_init(&opl3->voice_lock); 232 233 opl3->seq_client = -1; 234 235 /* allocate new client */ 236 opl_ver = (opl3->hardware & OPL3_HW_MASK) >> 8; 237 sprintf(name, "OPL%i FM synth", opl_ver); 238 client = opl3->seq_client = 239 snd_seq_create_kernel_client(opl3->card, opl3->seq_dev_num, 240 name); 241 if (client < 0) 242 return client; 243 244 if ((err = snd_opl3_synth_create_port(opl3)) < 0) { 245 snd_seq_delete_kernel_client(client); 246 opl3->seq_client = -1; 247 return err; 248 } 249 250 /* setup system timer */ 251 setup_timer(&opl3->tlist, snd_opl3_timer_func, (unsigned long) opl3); 252 spin_lock_init(&opl3->sys_timer_lock); 253 opl3->sys_timer_status = 0; 254 255 #if IS_ENABLED(CONFIG_SND_SEQUENCER_OSS) 256 snd_opl3_init_seq_oss(opl3, name); 257 #endif 258 return 0; 259 } 260 261 static int snd_opl3_seq_remove(struct device *_dev) 262 { 263 struct snd_seq_device *dev = to_seq_dev(_dev); 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 #if IS_ENABLED(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 struct snd_seq_driver opl3_seq_driver = { 281 .driver = { 282 .name = KBUILD_MODNAME, 283 .probe = snd_opl3_seq_probe, 284 .remove = snd_opl3_seq_remove, 285 }, 286 .id = SNDRV_SEQ_DEV_ID_OPL3, 287 .argsize = sizeof(struct snd_opl3 *), 288 }; 289 290 module_snd_seq_driver(opl3_seq_driver); 291