sound/core/seq/seq_dummy.c

   1 /*
   2  * ALSA sequencer MIDI-through client
   3  * Copyright (c) 1999-2000 by Takashi Iwai <tiwai@suse.de>
   4  *
   5  *   This program is free software; you can redistribute it and/or modify
   6  *   it under the terms of the GNU General Public License as published by
   7  *   the Free Software Foundation; either version 2 of the License, or
   8  *   (at your option) any later version.
   9  *
  10  *   This program is distributed in the hope that it will be useful,
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *   GNU General Public License for more details.
  14  *
  15  *   You should have received a copy of the GNU General Public License
  16  *   along with this program; if not, write to the Free Software
  17  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18  *
  19  */
  20
  21 #include <sound/driver.h>
  22 #include <linux/init.h>
  23 #include <linux/slab.h>
  24 #include <linux/moduleparam.h>
  25 #include <sound/core.h>
  26 #include "seq_clientmgr.h"
  27 #include <sound/initval.h>
  28 #include <sound/asoundef.h>
  29
  30 /*
  31
  32   Sequencer MIDI-through client
  33
  34   This gives a simple midi-through client.  All the normal input events
  35   are redirected to output port immediately.
  36   The routing can be done via aconnect program in alsa-utils.
  37
  38   Each client has a static client number 62 (= SNDRV_SEQ_CLIENT_DUMMY).
  39   If you want to auto-load this module, you may add the following alias
  40   in your /etc/conf.modules file.
  41
  42         alias snd-seq-client-62  snd-seq-dummy
  43
  44   The module is loaded on demand for client 62, or /proc/asound/seq/
  45   is accessed.  If you don't need this module to be loaded, alias
  46   snd-seq-client-62 as "off".  This will help modprobe.
  47
  48   The number of ports to be created can be specified via the module
  49   parameter "ports".  For example, to create four ports, add the
  50   following option in /etc/modprobe.conf:
  51
  52         option snd-seq-dummy ports=4
  53
  54   The modle option "duplex=1" enables duplex operation to the port.
  55   In duplex mode, a pair of ports are created instead of single port,
  56   and events are tunneled between pair-ports.  For example, input to
  57   port A is sent to output port of another port B and vice versa.
  58   In duplex mode, each port has DUPLEX capability.
  59
  60  */
  61
  62
  63 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
  64 MODULE_DESCRIPTION("ALSA sequencer MIDI-through client");
  65 MODULE_LICENSE("GPL");
  66 MODULE_ALIAS("snd-seq-client-" __stringify(SNDRV_SEQ_CLIENT_DUMMY));
  67
  68 static int ports = 1;
  69 static int duplex;
  70
  71 module_param(ports, int, 0444);
  72 MODULE_PARM_DESC(ports, "number of ports to be created");
  73 module_param(duplex, bool, 0444);
  74 MODULE_PARM_DESC(duplex, "create DUPLEX ports");
  75
  76 struct snd_seq_dummy_port {
  77         int client;
  78         int port;
  79         int duplex;
  80         int connect;
  81 };
  82
  83 static int my_client = -1;
  84
  85 /*
  86  * unuse callback - send ALL_SOUNDS_OFF and RESET_CONTROLLERS events
  87  * to subscribers.
  88  * Note: this callback is called only after all subscribers are removed.
  89  */
  90 static int
  91 dummy_unuse(void *private_data, struct snd_seq_port_subscribe *info)
  92 {
  93         struct snd_seq_dummy_port *p;
  94         int i;
  95         struct snd_seq_event ev;
  96
  97         p = private_data;
  98         memset(&ev, 0, sizeof(ev));
  99         if (p->duplex)
 100                 ev.source.port = p->connect;
 101         else
 102                 ev.source.port = p->port;
 103         ev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
 104         ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
 105         for (i = 0; i < 16; i++) {
 106                 ev.data.control.channel = i;
 107                 ev.data.control.param = MIDI_CTL_ALL_SOUNDS_OFF;
 108                 snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
 109                 ev.data.control.param = MIDI_CTL_RESET_CONTROLLERS;
 110                 snd_seq_kernel_client_dispatch(p->client, &ev, 0, 0);
 111         }
 112         return 0;
 113 }
 114
 115 /*
 116  * event input callback - just redirect events to subscribers
 117  */
 118 static int
 119 dummy_input(struct snd_seq_event *ev, int direct, void *private_data,
 120             int atomic, int hop)
 121 {
 122         struct snd_seq_dummy_port *p;
 123         struct snd_seq_event tmpev;
 124
 125         p = private_data;
 126         if (ev->source.client == SNDRV_SEQ_CLIENT_SYSTEM ||
 127             ev->type == SNDRV_SEQ_EVENT_KERNEL_ERROR)
 128                 return 0; /* ignore system messages */
 129         tmpev = *ev;
 130         if (p->duplex)
 131                 tmpev.source.port = p->connect;
 132         else
 133                 tmpev.source.port = p->port;
 134         tmpev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
 135         return snd_seq_kernel_client_dispatch(p->client, &tmpev, atomic, hop);
 136 }
 137
 138 /*
 139  * free_private callback
 140  */
 141 static void
 142 dummy_free(void *private_data)
 143 {
 144         kfree(private_data);
 145 }
 146
 147 /*
 148  * create a port
 149  */
 150 static struct snd_seq_dummy_port __init *
 151 create_port(int idx, int type)
 152 {
 153         struct snd_seq_port_info pinfo;
 154         struct snd_seq_port_callback pcb;
 155         struct snd_seq_dummy_port *rec;
 156
 157         if ((rec = kzalloc(sizeof(*rec), GFP_KERNEL)) == NULL)
 158                 return NULL;
 159
 160         rec->client = my_client;
 161         rec->duplex = duplex;
 162         rec->connect = 0;
 163         memset(&pinfo, 0, sizeof(pinfo));
 164         pinfo.addr.client = my_client;
 165         if (duplex)
 166                 sprintf(pinfo.name, "Midi Through Port-%d:%c", idx,
 167                         (type ? 'B' : 'A'));
 168         else
 169                 sprintf(pinfo.name, "Midi Through Port-%d", idx);
 170         pinfo.capability = SNDRV_SEQ_PORT_CAP_READ | SNDRV_SEQ_PORT_CAP_SUBS_READ;
 171         pinfo.capability |= SNDRV_SEQ_PORT_CAP_WRITE | SNDRV_SEQ_PORT_CAP_SUBS_WRITE;
 172         if (duplex)
 173                 pinfo.capability |= SNDRV_SEQ_PORT_CAP_DUPLEX;
 174         pinfo.type = SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC
 175                 | SNDRV_SEQ_PORT_TYPE_SOFTWARE
 176                 | SNDRV_SEQ_PORT_TYPE_PORT;
 177         memset(&pcb, 0, sizeof(pcb));
 178         pcb.owner = THIS_MODULE;
 179         pcb.unuse = dummy_unuse;
 180         pcb.event_input = dummy_input;
 181         pcb.private_free = dummy_free;
 182         pcb.private_data = rec;
 183         pinfo.kernel = &pcb;
 184         if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
 185                 kfree(rec);
 186                 return NULL;
 187         }
 188         rec->port = pinfo.addr.port;
 189         return rec;
 190 }
 191
 192 /*
 193  * register client and create ports
 194  */
 195 static int __init
 196 register_client(void)
 197 {
 198         struct snd_seq_dummy_port *rec1, *rec2;
 199         int i;
 200
 201         if (ports < 1) {
 202                 snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
 203                 return -EINVAL;
 204         }
 205
 206         /* create client */
 207         my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
 208                                                  "Midi Through");
 209         if (my_client < 0)
 210                 return my_client;
 211
 212         /* create ports */
 213         for (i = 0; i < ports; i++) {
 214                 rec1 = create_port(i, 0);
 215                 if (rec1 == NULL) {
 216                         snd_seq_delete_kernel_client(my_client);
 217                         return -ENOMEM;
 218                 }
 219                 if (duplex) {
 220                         rec2 = create_port(i, 1);
 221                         if (rec2 == NULL) {
 222                                 snd_seq_delete_kernel_client(my_client);
 223                                 return -ENOMEM;
 224                         }
 225                         rec1->connect = rec2->port;
 226                         rec2->connect = rec1->port;
 227                 }
 228         }
 229
 230         return 0;
 231 }
 232
 233 /*
 234  * delete client if exists
 235  */
 236 static void __exit
 237 delete_client(void)
 238 {
 239         if (my_client >= 0)
 240                 snd_seq_delete_kernel_client(my_client);
 241 }
 242
 243 /*
 244  *  Init part
 245  */
 246
 247 static int __init alsa_seq_dummy_init(void)
 248 {
 249         int err;
 250         snd_seq_autoload_lock();
 251         err = register_client();
 252         snd_seq_autoload_unlock();
 253         return err;
 254 }
 255
 256 static void __exit alsa_seq_dummy_exit(void)
 257 {
 258         delete_client();
 259 }
 260
 261 module_init(alsa_seq_dummy_init)
 262 module_exit(alsa_seq_dummy_exit)