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