sound/synth/emux/emux_oss.c

   1 /*
   2  *  Interface for OSS sequencer emulation
   3  *
   4  *  Copyright (C) 1999 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  * Changes
  21  * 19990227   Steve Ratcliffe   Made separate file and merged in latest
  22  *                              midi emulation.
  23  */
  24
  25
  26 #ifdef CONFIG_SND_SEQUENCER_OSS
  27
  28 #include <asm/uaccess.h>
  29 #include <sound/core.h>
  30 #include "emux_voice.h"
  31 #include <sound/asoundef.h>
  32
  33 static int snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure);
  34 static int snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg);
  35 static int snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd,
  36                                   unsigned long ioarg);
  37 static int snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
  38                                        const char __user *buf, int offs, int count);
  39 static int snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg);
  40 static int snd_emux_event_oss_input(struct snd_seq_event *ev, int direct,
  41                                     void *private, int atomic, int hop);
  42 static void reset_port_mode(struct snd_emux_port *port, int midi_mode);
  43 static void emuspec_control(struct snd_emux *emu, struct snd_emux_port *port,
  44                             int cmd, unsigned char *event, int atomic, int hop);
  45 static void gusspec_control(struct snd_emux *emu, struct snd_emux_port *port,
  46                             int cmd, unsigned char *event, int atomic, int hop);
  47 static void fake_event(struct snd_emux *emu, struct snd_emux_port *port,
  48                        int ch, int param, int val, int atomic, int hop);
  49
  50 /* operators */
  51 static struct snd_seq_oss_callback oss_callback = {
  52         .owner = THIS_MODULE,
  53         .open = snd_emux_open_seq_oss,
  54         .close = snd_emux_close_seq_oss,
  55         .ioctl = snd_emux_ioctl_seq_oss,
  56         .load_patch = snd_emux_load_patch_seq_oss,
  57         .reset = snd_emux_reset_seq_oss,
  58 };
  59
  60
  61 /*
  62  * register OSS synth
  63  */
  64
  65 void
  66 snd_emux_init_seq_oss(struct snd_emux *emu)
  67 {
  68         struct snd_seq_oss_reg *arg;
  69         struct snd_seq_device *dev;
  70
  71         if (snd_seq_device_new(emu->card, 0, SNDRV_SEQ_DEV_ID_OSS,
  72                                sizeof(struct snd_seq_oss_reg), &dev) < 0)
  73                 return;
  74
  75         emu->oss_synth = dev;
  76         strcpy(dev->name, emu->name);
  77         arg = SNDRV_SEQ_DEVICE_ARGPTR(dev);
  78         arg->type = SYNTH_TYPE_SAMPLE;
  79         arg->subtype = SAMPLE_TYPE_AWE32;
  80         arg->nvoices = emu->max_voices;
  81         arg->oper = oss_callback;
  82         arg->private_data = emu;
  83
  84         /* register to OSS synth table */
  85         snd_device_register(emu->card, dev);
  86 }
  87
  88
  89 /*
  90  * unregister
  91  */
  92 void
  93 snd_emux_detach_seq_oss(struct snd_emux *emu)
  94 {
  95         if (emu->oss_synth) {
  96                 snd_device_free(emu->card, emu->oss_synth);
  97                 emu->oss_synth = NULL;
  98         }
  99 }
 100
 101
 102 /* use port number as a unique soundfont client number */
 103 #define SF_CLIENT_NO(p) ((p) + 0x1000)
 104
 105 /*
 106  * open port for OSS sequencer
 107  */
 108 static int
 109 snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure)
 110 {
 111         struct snd_emux *emu;
 112         struct snd_emux_port *p;
 113         struct snd_seq_port_callback callback;
 114         char tmpname[64];
 115
 116         emu = closure;
 117         if (snd_BUG_ON(!arg || !emu))
 118                 return -ENXIO;
 119
 120         mutex_lock(&emu->register_mutex);
 121
 122         if (!snd_emux_inc_count(emu)) {
 123                 mutex_unlock(&emu->register_mutex);
 124                 return -EFAULT;
 125         }
 126
 127         memset(&callback, 0, sizeof(callback));
 128         callback.owner = THIS_MODULE;
 129         callback.event_input = snd_emux_event_oss_input;
 130
 131         sprintf(tmpname, "%s OSS Port", emu->name);
 132         p = snd_emux_create_port(emu, tmpname, 32,
 133                                  1, &callback);
 134         if (p == NULL) {
 135                 snd_printk(KERN_ERR "can't create port\n");
 136                 snd_emux_dec_count(emu);
 137                 mutex_unlock(&emu->register_mutex);
 138                 return -ENOMEM;
 139         }
 140
 141         /* fill the argument data */
 142         arg->private_data = p;
 143         arg->addr.client = p->chset.client;
 144         arg->addr.port = p->chset.port;
 145         p->oss_arg = arg;
 146
 147         reset_port_mode(p, arg->seq_mode);
 148
 149         snd_emux_reset_port(p);
 150
 151         mutex_unlock(&emu->register_mutex);
 152         return 0;
 153 }
 154
 155
 156 #define DEFAULT_DRUM_FLAGS      ((1<<9) | (1<<25))
 157
 158 /*
 159  * reset port mode
 160  */
 161 static void
 162 reset_port_mode(struct snd_emux_port *port, int midi_mode)
 163 {
 164         if (midi_mode) {
 165                 port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_MIDI;
 166                 port->drum_flags = DEFAULT_DRUM_FLAGS;
 167                 port->volume_atten = 0;
 168                 port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_KEYPRESS;
 169         } else {
 170                 port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_SYNTH;
 171                 port->drum_flags = 0;
 172                 port->volume_atten = 32;
 173                 port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_EVENTS;
 174         }
 175 }
 176
 177
 178 /*
 179  * close port
 180  */
 181 static int
 182 snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg)
 183 {
 184         struct snd_emux *emu;
 185         struct snd_emux_port *p;
 186
 187         if (snd_BUG_ON(!arg))
 188                 return -ENXIO;
 189         p = arg->private_data;
 190         if (snd_BUG_ON(!p))
 191                 return -ENXIO;
 192
 193         emu = p->emu;
 194         if (snd_BUG_ON(!emu))
 195                 return -ENXIO;
 196
 197         mutex_lock(&emu->register_mutex);
 198         snd_emux_sounds_off_all(p);
 199         snd_soundfont_close_check(emu->sflist, SF_CLIENT_NO(p->chset.port));
 200         snd_seq_event_port_detach(p->chset.client, p->chset.port);
 201         snd_emux_dec_count(emu);
 202
 203         mutex_unlock(&emu->register_mutex);
 204         return 0;
 205 }
 206
 207
 208 /*
 209  * load patch
 210  */
 211 static int
 212 snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
 213                             const char __user *buf, int offs, int count)
 214 {
 215         struct snd_emux *emu;
 216         struct snd_emux_port *p;
 217         int rc;
 218
 219         if (snd_BUG_ON(!arg))
 220                 return -ENXIO;
 221         p = arg->private_data;
 222         if (snd_BUG_ON(!p))
 223                 return -ENXIO;
 224
 225         emu = p->emu;
 226         if (snd_BUG_ON(!emu))
 227                 return -ENXIO;
 228
 229         if (format == GUS_PATCH)
 230                 rc = snd_soundfont_load_guspatch(emu->sflist, buf, count,
 231                                                  SF_CLIENT_NO(p->chset.port));
 232         else if (format == SNDRV_OSS_SOUNDFONT_PATCH) {
 233                 struct soundfont_patch_info patch;
 234                 if (count < (int)sizeof(patch))
 235                         rc = -EINVAL;
 236                 if (copy_from_user(&patch, buf, sizeof(patch)))
 237                         rc = -EFAULT;
 238                 if (patch.type >= SNDRV_SFNT_LOAD_INFO &&
 239                     patch.type <= SNDRV_SFNT_PROBE_DATA)
 240                         rc = snd_soundfont_load(emu->sflist, buf, count, SF_CLIENT_NO(p->chset.port));
 241                 else {
 242                         if (emu->ops.load_fx)
 243                                 rc = emu->ops.load_fx(emu, patch.type, patch.optarg, buf, count);
 244                         else
 245                                 rc = -EINVAL;
 246                 }
 247         } else
 248                 rc = 0;
 249         return rc;
 250 }
 251
 252
 253 /*
 254  * ioctl
 255  */
 256 static int
 257 snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg)
 258 {
 259         struct snd_emux_port *p;
 260         struct snd_emux *emu;
 261
 262         if (snd_BUG_ON(!arg))
 263                 return -ENXIO;
 264         p = arg->private_data;
 265         if (snd_BUG_ON(!p))
 266                 return -ENXIO;
 267
 268         emu = p->emu;
 269         if (snd_BUG_ON(!emu))
 270                 return -ENXIO;
 271
 272         switch (cmd) {
 273         case SNDCTL_SEQ_RESETSAMPLES:
 274                 snd_soundfont_remove_samples(emu->sflist);
 275                 return 0;
 276
 277         case SNDCTL_SYNTH_MEMAVL:
 278                 if (emu->memhdr)
 279                         return snd_util_mem_avail(emu->memhdr);
 280                 return 0;
 281         }
 282
 283         return 0;
 284 }
 285
 286
 287 /*
 288  * reset device
 289  */
 290 static int
 291 snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg)
 292 {
 293         struct snd_emux_port *p;
 294
 295         if (snd_BUG_ON(!arg))
 296                 return -ENXIO;
 297         p = arg->private_data;
 298         if (snd_BUG_ON(!p))
 299                 return -ENXIO;
 300         snd_emux_reset_port(p);
 301         return 0;
 302 }
 303
 304
 305 /*
 306  * receive raw events: only SEQ_PRIVATE is accepted.
 307  */
 308 static int
 309 snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_data,
 310                          int atomic, int hop)
 311 {
 312         struct snd_emux *emu;
 313         struct snd_emux_port *p;
 314         unsigned char cmd, *data;
 315
 316         p = private_data;
 317         if (snd_BUG_ON(!p))
 318                 return -EINVAL;
 319         emu = p->emu;
 320         if (snd_BUG_ON(!emu))
 321                 return -EINVAL;
 322         if (ev->type != SNDRV_SEQ_EVENT_OSS)
 323                 return snd_emux_event_input(ev, direct, private_data, atomic, hop);
 324
 325         data = ev->data.raw8.d;
 326         /* only SEQ_PRIVATE is accepted */
 327         if (data[0] != 0xfe)
 328                 return 0;
 329         cmd = data[2] & _EMUX_OSS_MODE_VALUE_MASK;
 330         if (data[2] & _EMUX_OSS_MODE_FLAG)
 331                 emuspec_control(emu, p, cmd, data, atomic, hop);
 332         else
 333                 gusspec_control(emu, p, cmd, data, atomic, hop);
 334         return 0;
 335 }
 336
 337
 338 /*
 339  * OSS/AWE driver specific h/w controls
 340  */
 341 static void
 342 emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd,
 343                 unsigned char *event, int atomic, int hop)
 344 {
 345         int voice;
 346         unsigned short p1;
 347         short p2;
 348         int i;
 349         struct snd_midi_channel *chan;
 350
 351         voice = event[3];
 352         if (voice < 0 || voice >= port->chset.max_channels)
 353                 chan = NULL;
 354         else
 355                 chan = &port->chset.channels[voice];
 356
 357         p1 = *(unsigned short *) &event[4];
 358         p2 = *(short *) &event[6];
 359
 360         switch (cmd) {
 361 #if 0 /* don't do this atomically */
 362         case _EMUX_OSS_REMOVE_LAST_SAMPLES:
 363                 snd_soundfont_remove_unlocked(emu->sflist);
 364                 break;
 365 #endif
 366         case _EMUX_OSS_SEND_EFFECT:
 367                 if (chan)
 368                         snd_emux_send_effect_oss(port, chan, p1, p2);
 369                 break;
 370
 371         case _EMUX_OSS_TERMINATE_ALL:
 372                 snd_emux_terminate_all(emu);
 373                 break;
 374
 375         case _EMUX_OSS_TERMINATE_CHANNEL:
 376                 /*snd_emux_mute_channel(emu, chan);*/
 377                 break;
 378         case _EMUX_OSS_RESET_CHANNEL:
 379                 /*snd_emux_channel_init(chset, chan);*/
 380                 break;
 381
 382         case _EMUX_OSS_RELEASE_ALL:
 383                 fake_event(emu, port, voice, MIDI_CTL_ALL_NOTES_OFF, 0, atomic, hop);
 384                 break;
 385         case _EMUX_OSS_NOTEOFF_ALL:
 386                 fake_event(emu, port, voice, MIDI_CTL_ALL_SOUNDS_OFF, 0, atomic, hop);
 387                 break;
 388
 389         case _EMUX_OSS_INITIAL_VOLUME:
 390                 if (p2) {
 391                         port->volume_atten = (short)p1;
 392                         snd_emux_update_port(port, SNDRV_EMUX_UPDATE_VOLUME);
 393                 }
 394                 break;
 395
 396         case _EMUX_OSS_CHN_PRESSURE:
 397                 if (chan) {
 398                         chan->midi_pressure = p1;
 399                         snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_FMMOD|SNDRV_EMUX_UPDATE_FM2FRQ2);
 400                 }
 401                 break;
 402
 403         case _EMUX_OSS_CHANNEL_MODE:
 404                 reset_port_mode(port, p1);
 405                 snd_emux_reset_port(port);
 406                 break;
 407
 408         case _EMUX_OSS_DRUM_CHANNELS:
 409                 port->drum_flags = *(unsigned int*)&event[4];
 410                 for (i = 0; i < port->chset.max_channels; i++) {
 411                         chan = &port->chset.channels[i];
 412                         chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0;
 413                 }
 414                 break;
 415
 416         case _EMUX_OSS_MISC_MODE:
 417                 if (p1 < EMUX_MD_END)
 418                         port->ctrls[p1] = p2;
 419                 break;
 420         case _EMUX_OSS_DEBUG_MODE:
 421                 break;
 422
 423         default:
 424                 if (emu->ops.oss_ioctl)
 425                         emu->ops.oss_ioctl(emu, cmd, p1, p2);
 426                 break;
 427         }
 428 }
 429
 430 /*
 431  * GUS specific h/w controls
 432  */
 433
 434 #include <linux/ultrasound.h>
 435
 436 static void
 437 gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd,
 438                 unsigned char *event, int atomic, int hop)
 439 {
 440         int voice;
 441         unsigned short p1;
 442         short p2;
 443         int plong;
 444         struct snd_midi_channel *chan;
 445
 446         if (port->port_mode != SNDRV_EMUX_PORT_MODE_OSS_SYNTH)
 447                 return;
 448         if (cmd == _GUS_NUMVOICES)
 449                 return;
 450         voice = event[3];
 451         if (voice < 0 || voice >= port->chset.max_channels)
 452                 return;
 453
 454         chan = &port->chset.channels[voice];
 455
 456         p1 = *(unsigned short *) &event[4];
 457         p2 = *(short *) &event[6];
 458         plong = *(int*) &event[4];
 459
 460         switch (cmd) {
 461         case _GUS_VOICESAMPLE:
 462                 chan->midi_program = p1;
 463                 return;
 464
 465         case _GUS_VOICEBALA:
 466                 /* 0 to 15 --> 0 to 127 */
 467                 chan->control[MIDI_CTL_MSB_PAN] = (int)p1 << 3;
 468                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN);
 469                 return;
 470
 471         case _GUS_VOICEVOL:
 472         case _GUS_VOICEVOL2:
 473                 /* not supported yet */
 474                 return;
 475
 476         case _GUS_RAMPRANGE:
 477         case _GUS_RAMPRATE:
 478         case _GUS_RAMPMODE:
 479         case _GUS_RAMPON:
 480         case _GUS_RAMPOFF:
 481                 /* volume ramping not supported */
 482                 return;
 483
 484         case _GUS_VOLUME_SCALE:
 485                 return;
 486
 487         case _GUS_VOICE_POS:
 488 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
 489                 snd_emux_send_effect(port, chan, EMUX_FX_SAMPLE_START,
 490                                      (short)(plong & 0x7fff),
 491                                      EMUX_FX_FLAG_SET);
 492                 snd_emux_send_effect(port, chan, EMUX_FX_COARSE_SAMPLE_START,
 493                                      (plong >> 15) & 0xffff,
 494                                      EMUX_FX_FLAG_SET);
 495 #endif
 496                 return;
 497         }
 498 }
 499
 500
 501 /*
 502  * send an event to midi emulation
 503  */
 504 static void
 505 fake_event(struct snd_emux *emu, struct snd_emux_port *port, int ch, int param, int val, int atomic, int hop)
 506 {
 507         struct snd_seq_event ev;
 508         memset(&ev, 0, sizeof(ev));
 509         ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
 510         ev.data.control.channel = ch;
 511         ev.data.control.param = param;
 512         ev.data.control.value = val;
 513         snd_emux_event_input(&ev, 0, port, atomic, hop);
 514 }
 515
 516 #endif /* CONFIG_SND_SEQUENCER_OSS */