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 = 0;
  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         memset(&pcb, 0, sizeof(pcb));
 176         pcb.owner = THIS_MODULE;
 177         pcb.unuse = dummy_unuse;
 178         pcb.event_input = dummy_input;
 179         pcb.private_free = dummy_free;
 180         pcb.private_data = rec;
 181         pinfo.kernel = &pcb;
 182         if (snd_seq_kernel_client_ctl(my_client, SNDRV_SEQ_IOCTL_CREATE_PORT, &pinfo) < 0) {
 183                 kfree(rec);
 184                 return NULL;
 185         }
 186         rec->port = pinfo.addr.port;
 187         return rec;
 188 }
 189
 190 /*
 191  * register client and create ports
 192  */
 193 static int __init
 194 register_client(void)
 195 {
 196         struct snd_seq_dummy_port *rec1, *rec2;
 197         int i;
 198
 199         if (ports < 1) {
 200                 snd_printk(KERN_ERR "invalid number of ports %d\n", ports);
 201                 return -EINVAL;
 202         }
 203
 204         /* create client */
 205         my_client = snd_seq_create_kernel_client(NULL, SNDRV_SEQ_CLIENT_DUMMY,
 206                                                  "Midi Through");
 207         if (my_client < 0)
 208                 return my_client;
 209
 210         /* create ports */
 211         for (i = 0; i < ports; i++) {
 212                 rec1 = create_port(i, 0);
 213                 if (rec1 == NULL) {
 214                         snd_seq_delete_kernel_client(my_client);
 215                         return -ENOMEM;
 216                 }
 217                 if (duplex) {
 218                         rec2 = create_port(i, 1);
 219                         if (rec2 == NULL) {
 220                                 snd_seq_delete_kernel_client(my_client);
 221                                 return -ENOMEM;
 222                         }
 223                         rec1->connect = rec2->port;
 224                         rec2->connect = rec1->port;
 225                 }
 226         }
 227
 228         return 0;
 229 }
 230
 231 /*
 232  * delete client if exists
 233  */
 234 static void __exit
 235 delete_client(void)
 236 {
 237         if (my_client >= 0)
 238                 snd_seq_delete_kernel_client(my_client);
 239 }
 240
 241 /*
 242  *  Init part
 243  */
 244
 245 static int __init alsa_seq_dummy_init(void)
 246 {
 247         int err;
 248         snd_seq_autoload_lock();
 249         err = register_client();
 250         snd_seq_autoload_unlock();
 251         return err;
 252 }
 253
 254 static void __exit alsa_seq_dummy_exit(void)
 255 {
 256         delete_client();
 257 }
 258
 259 module_init(alsa_seq_dummy_init)
 260 module_exit(alsa_seq_dummy_exit)