sound/core/seq/oss/seq_oss_init.c

   1 /*
   2  * OSS compatible sequencer driver
   3  *
   4  * open/close and reset interface
   5  *
   6  * Copyright (C) 1998-1999 Takashi Iwai <tiwai@suse.de>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 #include "seq_oss_device.h"
  24 #include "seq_oss_synth.h"
  25 #include "seq_oss_midi.h"
  26 #include "seq_oss_writeq.h"
  27 #include "seq_oss_readq.h"
  28 #include "seq_oss_timer.h"
  29 #include "seq_oss_event.h"
  30 #include <linux/init.h>
  31 #include <linux/moduleparam.h>
  32
  33 /*
  34  * common variables
  35  */
  36 static int maxqlen = SNDRV_SEQ_OSS_MAX_QLEN;
  37 module_param(maxqlen, int, 0444);
  38 MODULE_PARM_DESC(maxqlen, "maximum queue length");
  39
  40 static int system_client = -1; /* ALSA sequencer client number */
  41 static int system_port = -1;
  42
  43 static int num_clients;
  44 static struct seq_oss_devinfo *client_table[SNDRV_SEQ_OSS_MAX_CLIENTS];
  45
  46
  47 /*
  48  * prototypes
  49  */
  50 static int receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop);
  51 static int translate_mode(struct file *file);
  52 static int create_port(struct seq_oss_devinfo *dp);
  53 static int delete_port(struct seq_oss_devinfo *dp);
  54 static int alloc_seq_queue(struct seq_oss_devinfo *dp);
  55 static int delete_seq_queue(int queue);
  56 static void free_devinfo(void *private);
  57
  58 #define call_ctl(type,rec) snd_seq_kernel_client_ctl(system_client, type, rec)
  59
  60
  61 /*
  62  * create sequencer client for OSS sequencer
  63  */
  64 int __init
  65 snd_seq_oss_create_client(void)
  66 {
  67         int rc;
  68         struct snd_seq_port_info *port;
  69         struct snd_seq_port_callback port_callback;
  70
  71         port = kmalloc(sizeof(*port), GFP_KERNEL);
  72         if (!port) {
  73                 rc = -ENOMEM;
  74                 goto __error;
  75         }
  76
  77         /* create ALSA client */
  78         rc = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_OSS,
  79                                           "OSS sequencer");
  80         if (rc < 0)
  81                 goto __error;
  82
  83         system_client = rc;
  84         debug_printk(("new client = %d\n", rc));
  85
  86         /* look up midi devices */
  87         snd_seq_oss_midi_lookup_ports(system_client);
  88
  89         /* create annoucement receiver port */
  90         memset(port, 0, sizeof(*port));
  91         strcpy(port->name, "Receiver");
  92         port->addr.client = system_client;
  93         port->capability = SNDRV_SEQ_PORT_CAP_WRITE; /* receive only */
  94         port->type = 0;
  95
  96         memset(&port_callback, 0, sizeof(port_callback));
  97         /* don't set port_callback.owner here. otherwise the module counter
  98          * is incremented and we can no longer release the module..
  99          */
 100         port_callback.event_input = receive_announce;
 101         port->kernel = &port_callback;
 102
 103         call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, port);
 104         if ((system_port = port->addr.port) >= 0) {
 105                 struct snd_seq_port_subscribe subs;
 106
 107                 memset(&subs, 0, sizeof(subs));
 108                 subs.sender.client = SNDRV_SEQ_CLIENT_SYSTEM;
 109                 subs.sender.port = SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE;
 110                 subs.dest.client = system_client;
 111                 subs.dest.port = system_port;
 112                 call_ctl(SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, &subs);
 113         }
 114         rc = 0;
 115
 116  __error:
 117         kfree(port);
 118         return rc;
 119 }
 120
 121
 122 /*
 123  * receive annoucement from system port, and check the midi device
 124  */
 125 static int
 126 receive_announce(struct snd_seq_event *ev, int direct, void *private, int atomic, int hop)
 127 {
 128         struct snd_seq_port_info pinfo;
 129
 130         if (atomic)
 131                 return 0; /* it must not happen */
 132
 133         switch (ev->type) {
 134         case SNDRV_SEQ_EVENT_PORT_START:
 135         case SNDRV_SEQ_EVENT_PORT_CHANGE:
 136                 if (ev->data.addr.client == system_client)
 137                         break; /* ignore myself */
 138                 memset(&pinfo, 0, sizeof(pinfo));
 139                 pinfo.addr = ev->data.addr;
 140                 if (call_ctl(SNDRV_SEQ_IOCTL_GET_PORT_INFO, &pinfo) >= 0)
 141                         snd_seq_oss_midi_check_new_port(&pinfo);
 142                 break;
 143
 144         case SNDRV_SEQ_EVENT_PORT_EXIT:
 145                 if (ev->data.addr.client == system_client)
 146                         break; /* ignore myself */
 147                 snd_seq_oss_midi_check_exit_port(ev->data.addr.client,
 148                                                 ev->data.addr.port);
 149                 break;
 150         }
 151         return 0;
 152 }
 153
 154
 155 /*
 156  * delete OSS sequencer client
 157  */
 158 int
 159 snd_seq_oss_delete_client(void)
 160 {
 161         if (system_client >= 0)
 162                 snd_seq_delete_kernel_client(system_client);
 163
 164         snd_seq_oss_midi_clear_all();
 165
 166         return 0;
 167 }
 168
 169
 170 /*
 171  * open sequencer device
 172  */
 173 int
 174 snd_seq_oss_open(struct file *file, int level)
 175 {
 176         int i, rc;
 177         struct seq_oss_devinfo *dp;
 178
 179         if ((dp = kzalloc(sizeof(*dp), GFP_KERNEL)) == NULL) {
 180                 snd_printk(KERN_ERR "can't malloc device info\n");
 181                 return -ENOMEM;
 182         }
 183         debug_printk(("oss_open: dp = %p\n", dp));
 184
 185         for (i = 0; i < SNDRV_SEQ_OSS_MAX_CLIENTS; i++) {
 186                 if (client_table[i] == NULL)
 187                         break;
 188         }
 189         if (i >= SNDRV_SEQ_OSS_MAX_CLIENTS) {
 190                 snd_printk(KERN_ERR "too many applications\n");
 191                 kfree(dp);
 192                 return -ENOMEM;
 193         }
 194
 195         dp->index = i;
 196         dp->cseq = system_client;
 197         dp->port = -1;
 198         dp->queue = -1;
 199         dp->readq = NULL;
 200         dp->writeq = NULL;
 201
 202         /* look up synth and midi devices */
 203         snd_seq_oss_synth_setup(dp);
 204         snd_seq_oss_midi_setup(dp);
 205
 206         if (dp->synth_opened == 0 && dp->max_mididev == 0) {
 207                 /* snd_printk(KERN_ERR "no device found\n"); */
 208                 rc = -ENODEV;
 209                 goto _error;
 210         }
 211
 212         /* create port */
 213         debug_printk(("create new port\n"));
 214         if ((rc = create_port(dp)) < 0) {
 215                 snd_printk(KERN_ERR "can't create port\n");
 216                 goto _error;
 217         }
 218
 219         /* allocate queue */
 220         debug_printk(("allocate queue\n"));
 221         if ((rc = alloc_seq_queue(dp)) < 0)
 222                 goto _error;
 223
 224         /* set address */
 225         dp->addr.client = dp->cseq;
 226         dp->addr.port = dp->port;
 227         /*dp->addr.queue = dp->queue;*/
 228         /*dp->addr.channel = 0;*/
 229
 230         dp->seq_mode = level;
 231
 232         /* set up file mode */
 233         dp->file_mode = translate_mode(file);
 234
 235         /* initialize read queue */
 236         debug_printk(("initialize read queue\n"));
 237         if (is_read_mode(dp->file_mode)) {
 238                 if ((dp->readq = snd_seq_oss_readq_new(dp, maxqlen)) == NULL) {
 239                         rc = -ENOMEM;
 240                         goto _error;
 241                 }
 242         }
 243
 244         /* initialize write queue */
 245         debug_printk(("initialize write queue\n"));
 246         if (is_write_mode(dp->file_mode)) {
 247                 dp->writeq = snd_seq_oss_writeq_new(dp, maxqlen);
 248                 if (dp->writeq == NULL) {
 249                         rc = -ENOMEM;
 250                         goto _error;
 251                 }
 252         }
 253
 254         /* initialize timer */
 255         debug_printk(("initialize timer\n"));
 256         if ((dp->timer = snd_seq_oss_timer_new(dp)) == NULL) {
 257                 snd_printk(KERN_ERR "can't alloc timer\n");
 258                 rc = -ENOMEM;
 259                 goto _error;
 260         }
 261         debug_printk(("timer initialized\n"));
 262
 263         /* set private data pointer */
 264         file->private_data = dp;
 265
 266         /* set up for mode2 */
 267         if (level == SNDRV_SEQ_OSS_MODE_MUSIC)
 268                 snd_seq_oss_synth_setup_midi(dp);
 269         else if (is_read_mode(dp->file_mode))
 270                 snd_seq_oss_midi_open_all(dp, SNDRV_SEQ_OSS_FILE_READ);
 271
 272         client_table[dp->index] = dp;
 273         num_clients++;
 274
 275         debug_printk(("open done\n"));
 276         return 0;
 277
 278  _error:
 279         snd_seq_oss_synth_cleanup(dp);
 280         snd_seq_oss_midi_cleanup(dp);
 281         i = dp->queue;
 282         delete_port(dp);
 283         delete_seq_queue(i);
 284
 285         return rc;
 286 }
 287
 288 /*
 289  * translate file flags to private mode
 290  */
 291 static int
 292 translate_mode(struct file *file)
 293 {
 294         int file_mode = 0;
 295         if ((file->f_flags & O_ACCMODE) != O_RDONLY)
 296                 file_mode |= SNDRV_SEQ_OSS_FILE_WRITE;
 297         if ((file->f_flags & O_ACCMODE) != O_WRONLY)
 298                 file_mode |= SNDRV_SEQ_OSS_FILE_READ;
 299         if (file->f_flags & O_NONBLOCK)
 300                 file_mode |= SNDRV_SEQ_OSS_FILE_NONBLOCK;
 301         return file_mode;
 302 }
 303
 304
 305 /*
 306  * create sequencer port
 307  */
 308 static int
 309 create_port(struct seq_oss_devinfo *dp)
 310 {
 311         int rc;
 312         struct snd_seq_port_info port;
 313         struct snd_seq_port_callback callback;
 314
 315         memset(&port, 0, sizeof(port));
 316         port.addr.client = dp->cseq;
 317         sprintf(port.name, "Sequencer-%d", dp->index);
 318         port.capability = SNDRV_SEQ_PORT_CAP_READ|SNDRV_SEQ_PORT_CAP_WRITE; /* no subscription */
 319         port.type = SNDRV_SEQ_PORT_TYPE_SPECIFIC;
 320         port.midi_channels = 128;
 321         port.synth_voices = 128;
 322
 323         memset(&callback, 0, sizeof(callback));
 324         callback.owner = THIS_MODULE;
 325         callback.private_data = dp;
 326         callback.event_input = snd_seq_oss_event_input;
 327         callback.private_free = free_devinfo;
 328         port.kernel = &callback;
 329
 330         rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_PORT, &port);
 331         if (rc < 0)
 332                 return rc;
 333
 334         dp->port = port.addr.port;
 335         debug_printk(("new port = %d\n", port.addr.port));
 336
 337         return 0;
 338 }
 339
 340 /*
 341  * delete ALSA port
 342  */
 343 static int
 344 delete_port(struct seq_oss_devinfo *dp)
 345 {
 346         if (dp->port < 0)
 347                 return 0;
 348
 349         debug_printk(("delete_port %i\n", dp->port));
 350         return snd_seq_event_port_detach(dp->cseq, dp->port);
 351 }
 352
 353 /*
 354  * allocate a queue
 355  */
 356 static int
 357 alloc_seq_queue(struct seq_oss_devinfo *dp)
 358 {
 359         struct snd_seq_queue_info qinfo;
 360         int rc;
 361
 362         memset(&qinfo, 0, sizeof(qinfo));
 363         qinfo.owner = system_client;
 364         qinfo.locked = 1;
 365         strcpy(qinfo.name, "OSS Sequencer Emulation");
 366         if ((rc = call_ctl(SNDRV_SEQ_IOCTL_CREATE_QUEUE, &qinfo)) < 0)
 367                 return rc;
 368         dp->queue = qinfo.queue;
 369         return 0;
 370 }
 371
 372 /*
 373  * release queue
 374  */
 375 static int
 376 delete_seq_queue(int queue)
 377 {
 378         struct snd_seq_queue_info qinfo;
 379         int rc;
 380
 381         if (queue < 0)
 382                 return 0;
 383         memset(&qinfo, 0, sizeof(qinfo));
 384         qinfo.queue = queue;
 385         rc = call_ctl(SNDRV_SEQ_IOCTL_DELETE_QUEUE, &qinfo);
 386         if (rc < 0)
 387                 printk(KERN_ERR "seq-oss: unable to delete queue %d (%d)\n", queue, rc);
 388         return rc;
 389 }
 390
 391
 392 /*
 393  * free device informations - private_free callback of port
 394  */
 395 static void
 396 free_devinfo(void *private)
 397 {
 398         struct seq_oss_devinfo *dp = (struct seq_oss_devinfo *)private;
 399
 400         if (dp->timer)
 401                 snd_seq_oss_timer_delete(dp->timer);
 402
 403         if (dp->writeq)
 404                 snd_seq_oss_writeq_delete(dp->writeq);
 405
 406         if (dp->readq)
 407                 snd_seq_oss_readq_delete(dp->readq);
 408
 409         kfree(dp);
 410 }
 411
 412
 413 /*
 414  * close sequencer device
 415  */
 416 void
 417 snd_seq_oss_release(struct seq_oss_devinfo *dp)
 418 {
 419         int queue;
 420
 421         client_table[dp->index] = NULL;
 422         num_clients--;
 423
 424         debug_printk(("resetting..\n"));
 425         snd_seq_oss_reset(dp);
 426
 427         debug_printk(("cleaning up..\n"));
 428         snd_seq_oss_synth_cleanup(dp);
 429         snd_seq_oss_midi_cleanup(dp);
 430
 431         /* clear slot */
 432         debug_printk(("releasing resource..\n"));
 433         queue = dp->queue;
 434         if (dp->port >= 0)
 435                 delete_port(dp);
 436         delete_seq_queue(queue);
 437
 438         debug_printk(("release done\n"));
 439 }
 440
 441
 442 /*
 443  * Wait until the queue is empty (if we don't have nonblock)
 444  */
 445 void
 446 snd_seq_oss_drain_write(struct seq_oss_devinfo *dp)
 447 {
 448         if (! dp->timer->running)
 449                 return;
 450         if (is_write_mode(dp->file_mode) && !is_nonblock_mode(dp->file_mode) &&
 451             dp->writeq) {
 452                 debug_printk(("syncing..\n"));
 453                 while (snd_seq_oss_writeq_sync(dp->writeq))
 454                         ;
 455         }
 456 }
 457
 458
 459 /*
 460  * reset sequencer devices
 461  */
 462 void
 463 snd_seq_oss_reset(struct seq_oss_devinfo *dp)
 464 {
 465         int i;
 466
 467         /* reset all synth devices */
 468         for (i = 0; i < dp->max_synthdev; i++)
 469                 snd_seq_oss_synth_reset(dp, i);
 470
 471         /* reset all midi devices */
 472         if (dp->seq_mode != SNDRV_SEQ_OSS_MODE_MUSIC) {
 473                 for (i = 0; i < dp->max_mididev; i++)
 474                         snd_seq_oss_midi_reset(dp, i);
 475         }
 476
 477         /* remove queues */
 478         if (dp->readq)
 479                 snd_seq_oss_readq_clear(dp->readq);
 480         if (dp->writeq)
 481                 snd_seq_oss_writeq_clear(dp->writeq);
 482
 483         /* reset timer */
 484         snd_seq_oss_timer_stop(dp->timer);
 485 }
 486
 487
 488 #ifdef CONFIG_PROC_FS
 489 /*
 490  * misc. functions for proc interface
 491  */
 492 char *
 493 enabled_str(int bool)
 494 {
 495         return bool ? "enabled" : "disabled";
 496 }
 497
 498 static char *
 499 filemode_str(int val)
 500 {
 501         static char *str[] = {
 502                 "none", "read", "write", "read/write",
 503         };
 504         return str[val & SNDRV_SEQ_OSS_FILE_ACMODE];
 505 }
 506
 507
 508 /*
 509  * proc interface
 510  */
 511 void
 512 snd_seq_oss_system_info_read(struct snd_info_buffer *buf)
 513 {
 514         int i;
 515         struct seq_oss_devinfo *dp;
 516
 517         snd_iprintf(buf, "ALSA client number %d\n", system_client);
 518         snd_iprintf(buf, "ALSA receiver port %d\n", system_port);
 519
 520         snd_iprintf(buf, "\nNumber of applications: %d\n", num_clients);
 521         for (i = 0; i < num_clients; i++) {
 522                 snd_iprintf(buf, "\nApplication %d: ", i);
 523                 if ((dp = client_table[i]) == NULL) {
 524                         snd_iprintf(buf, "*empty*\n");
 525                         continue;
 526                 }
 527                 snd_iprintf(buf, "port %d : queue %d\n", dp->port, dp->queue);
 528                 snd_iprintf(buf, "  sequencer mode = %s : file open mode = %s\n",
 529                             (dp->seq_mode ? "music" : "synth"),
 530                             filemode_str(dp->file_mode));
 531                 if (dp->seq_mode)
 532                         snd_iprintf(buf, "  timer tempo = %d, timebase = %d\n",
 533                                     dp->timer->oss_tempo, dp->timer->oss_timebase);
 534                 snd_iprintf(buf, "  max queue length %d\n", maxqlen);
 535                 if (is_read_mode(dp->file_mode) && dp->readq)
 536                         snd_seq_oss_readq_info_read(dp->readq, buf);
 537         }
 538 }
 539 #endif /* CONFIG_PROC_FS */