eefd1cf872b49efac2f67d35831cc54b061d0163
[linux-2.6.git] / sound / core / seq / seq_ports.c
1 /*
2  *   ALSA sequencer Ports
3  *   Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
4  *                         Jaroslav Kysela <perex@suse.cz>
5  *
6  *
7  *   This program is free software; you can redistribute it and/or modify
8  *   it under the terms of the GNU General Public License as published by
9  *   the Free Software Foundation; either version 2 of the License, or
10  *   (at your option) any later version.
11  *
12  *   This program is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with this program; if not, write to the Free Software
19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20  *
21  */
22
23 #include <sound/driver.h>
24 #include <sound/core.h>
25 #include <linux/slab.h>
26 #include "seq_system.h"
27 #include "seq_ports.h"
28 #include "seq_clientmgr.h"
29
30 /*
31
32    registration of client ports
33
34  */
35
36
37 /* 
38
39 NOTE: the current implementation of the port structure as a linked list is
40 not optimal for clients that have many ports. For sending messages to all
41 subscribers of a port we first need to find the address of the port
42 structure, which means we have to traverse the list. A direct access table
43 (array) would be better, but big preallocated arrays waste memory.
44
45 Possible actions:
46
47 1) leave it this way, a client does normaly does not have more than a few
48 ports
49
50 2) replace the linked list of ports by a array of pointers which is
51 dynamicly kmalloced. When a port is added or deleted we can simply allocate
52 a new array, copy the corresponding pointers, and delete the old one. We
53 then only need a pointer to this array, and an integer that tells us how
54 much elements are in array.
55
56 */
57
58 /* return pointer to port structure - port is locked if found */
59 struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client,
60                                                  int num)
61 {
62         struct snd_seq_client_port *port;
63
64         if (client == NULL)
65                 return NULL;
66         read_lock(&client->ports_lock);
67         list_for_each_entry(port, &client->ports_list_head, list) {
68                 if (port->addr.port == num) {
69                         if (port->closing)
70                                 break; /* deleting now */
71                         snd_use_lock_use(&port->use_lock);
72                         read_unlock(&client->ports_lock);
73                         return port;
74                 }
75         }
76         read_unlock(&client->ports_lock);
77         return NULL;            /* not found */
78 }
79
80
81 /* search for the next port - port is locked if found */
82 struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
83                                                        struct snd_seq_port_info *pinfo)
84 {
85         int num;
86         struct snd_seq_client_port *port, *found;
87
88         num = pinfo->addr.port;
89         found = NULL;
90         read_lock(&client->ports_lock);
91         list_for_each_entry(port, &client->ports_list_head, list) {
92                 if (port->addr.port < num)
93                         continue;
94                 if (port->addr.port == num) {
95                         found = port;
96                         break;
97                 }
98                 if (found == NULL || port->addr.port < found->addr.port)
99                         found = port;
100         }
101         if (found) {
102                 if (found->closing)
103                         found = NULL;
104                 else
105                         snd_use_lock_use(&found->use_lock);
106         }
107         read_unlock(&client->ports_lock);
108         return found;
109 }
110
111
112 /* initialize snd_seq_port_subs_info */
113 static void port_subs_info_init(struct snd_seq_port_subs_info *grp)
114 {
115         INIT_LIST_HEAD(&grp->list_head);
116         grp->count = 0;
117         grp->exclusive = 0;
118         rwlock_init(&grp->list_lock);
119         init_rwsem(&grp->list_mutex);
120         grp->open = NULL;
121         grp->close = NULL;
122 }
123
124
125 /* create a port, port number is returned (-1 on failure) */
126 struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
127                                                 int port)
128 {
129         unsigned long flags;
130         struct snd_seq_client_port *new_port, *p;
131         int num = -1;
132         
133         /* sanity check */
134         snd_assert(client, return NULL);
135
136         if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
137                 snd_printk(KERN_WARNING "too many ports for client %d\n", client->number);
138                 return NULL;
139         }
140
141         /* create a new port */
142         new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
143         if (! new_port) {
144                 snd_printd("malloc failed for registering client port\n");
145                 return NULL;    /* failure, out of memory */
146         }
147         /* init port data */
148         new_port->addr.client = client->number;
149         new_port->addr.port = -1;
150         new_port->owner = THIS_MODULE;
151         sprintf(new_port->name, "port-%d", num);
152         snd_use_lock_init(&new_port->use_lock);
153         port_subs_info_init(&new_port->c_src);
154         port_subs_info_init(&new_port->c_dest);
155
156         num = port >= 0 ? port : 0;
157         mutex_lock(&client->ports_mutex);
158         write_lock_irqsave(&client->ports_lock, flags);
159         list_for_each_entry(p, &client->ports_list_head, list) {
160                 if (p->addr.port > num)
161                         break;
162                 if (port < 0) /* auto-probe mode */
163                         num = p->addr.port + 1;
164         }
165         /* insert the new port */
166         list_add_tail(&new_port->list, &p->list);
167         client->num_ports++;
168         new_port->addr.port = num;      /* store the port number in the port */
169         write_unlock_irqrestore(&client->ports_lock, flags);
170         mutex_unlock(&client->ports_mutex);
171         sprintf(new_port->name, "port-%d", num);
172
173         return new_port;
174 }
175
176 /* */
177 enum group_type {
178         SRC_LIST, DEST_LIST
179 };
180
181 static int subscribe_port(struct snd_seq_client *client,
182                           struct snd_seq_client_port *port,
183                           struct snd_seq_port_subs_info *grp,
184                           struct snd_seq_port_subscribe *info, int send_ack);
185 static int unsubscribe_port(struct snd_seq_client *client,
186                             struct snd_seq_client_port *port,
187                             struct snd_seq_port_subs_info *grp,
188                             struct snd_seq_port_subscribe *info, int send_ack);
189
190
191 static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr,
192                                                    struct snd_seq_client **cp)
193 {
194         struct snd_seq_client_port *p;
195         *cp = snd_seq_client_use_ptr(addr->client);
196         if (*cp) {
197                 p = snd_seq_port_use_ptr(*cp, addr->port);
198                 if (! p) {
199                         snd_seq_client_unlock(*cp);
200                         *cp = NULL;
201                 }
202                 return p;
203         }
204         return NULL;
205 }
206
207 /*
208  * remove all subscribers on the list
209  * this is called from port_delete, for each src and dest list.
210  */
211 static void clear_subscriber_list(struct snd_seq_client *client,
212                                   struct snd_seq_client_port *port,
213                                   struct snd_seq_port_subs_info *grp,
214                                   int grptype)
215 {
216         struct list_head *p, *n;
217
218         list_for_each_safe(p, n, &grp->list_head) {
219                 struct snd_seq_subscribers *subs;
220                 struct snd_seq_client *c;
221                 struct snd_seq_client_port *aport;
222
223                 if (grptype == SRC_LIST) {
224                         subs = list_entry(p, struct snd_seq_subscribers, src_list);
225                         aport = get_client_port(&subs->info.dest, &c);
226                 } else {
227                         subs = list_entry(p, struct snd_seq_subscribers, dest_list);
228                         aport = get_client_port(&subs->info.sender, &c);
229                 }
230                 list_del(p);
231                 unsubscribe_port(client, port, grp, &subs->info, 0);
232                 if (!aport) {
233                         /* looks like the connected port is being deleted.
234                          * we decrease the counter, and when both ports are deleted
235                          * remove the subscriber info
236                          */
237                         if (atomic_dec_and_test(&subs->ref_count))
238                                 kfree(subs);
239                 } else {
240                         /* ok we got the connected port */
241                         struct snd_seq_port_subs_info *agrp;
242                         agrp = (grptype == SRC_LIST) ? &aport->c_dest : &aport->c_src;
243                         down_write(&agrp->list_mutex);
244                         if (grptype == SRC_LIST)
245                                 list_del(&subs->dest_list);
246                         else
247                                 list_del(&subs->src_list);
248                         up_write(&agrp->list_mutex);
249                         unsubscribe_port(c, aport, agrp, &subs->info, 1);
250                         kfree(subs);
251                         snd_seq_port_unlock(aport);
252                         snd_seq_client_unlock(c);
253                 }
254         }
255 }
256
257 /* delete port data */
258 static int port_delete(struct snd_seq_client *client,
259                        struct snd_seq_client_port *port)
260 {
261         /* set closing flag and wait for all port access are gone */
262         port->closing = 1;
263         snd_use_lock_sync(&port->use_lock); 
264
265         /* clear subscribers info */
266         clear_subscriber_list(client, port, &port->c_src, SRC_LIST);
267         clear_subscriber_list(client, port, &port->c_dest, DEST_LIST);
268
269         if (port->private_free)
270                 port->private_free(port->private_data);
271
272         snd_assert(port->c_src.count == 0,);
273         snd_assert(port->c_dest.count == 0,);
274
275         kfree(port);
276         return 0;
277 }
278
279
280 /* delete a port with the given port id */
281 int snd_seq_delete_port(struct snd_seq_client *client, int port)
282 {
283         unsigned long flags;
284         struct snd_seq_client_port *found = NULL, *p;
285
286         mutex_lock(&client->ports_mutex);
287         write_lock_irqsave(&client->ports_lock, flags);
288         list_for_each_entry(p, &client->ports_list_head, list) {
289                 if (p->addr.port == port) {
290                         /* ok found.  delete from the list at first */
291                         list_del(&p->list);
292                         client->num_ports--;
293                         found = p;
294                         break;
295                 }
296         }
297         write_unlock_irqrestore(&client->ports_lock, flags);
298         mutex_unlock(&client->ports_mutex);
299         if (found)
300                 return port_delete(client, found);
301         else
302                 return -ENOENT;
303 }
304
305 /* delete the all ports belonging to the given client */
306 int snd_seq_delete_all_ports(struct snd_seq_client *client)
307 {
308         unsigned long flags;
309         struct list_head deleted_list;
310         struct snd_seq_client_port *port, *tmp;
311         
312         /* move the port list to deleted_list, and
313          * clear the port list in the client data.
314          */
315         mutex_lock(&client->ports_mutex);
316         write_lock_irqsave(&client->ports_lock, flags);
317         if (! list_empty(&client->ports_list_head)) {
318                 list_add(&deleted_list, &client->ports_list_head);
319                 list_del_init(&client->ports_list_head);
320         } else {
321                 INIT_LIST_HEAD(&deleted_list);
322         }
323         client->num_ports = 0;
324         write_unlock_irqrestore(&client->ports_lock, flags);
325
326         /* remove each port in deleted_list */
327         list_for_each_entry_safe(port, tmp, &deleted_list, list) {
328                 list_del(&port->list);
329                 snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port);
330                 port_delete(client, port);
331         }
332         mutex_unlock(&client->ports_mutex);
333         return 0;
334 }
335
336 /* set port info fields */
337 int snd_seq_set_port_info(struct snd_seq_client_port * port,
338                           struct snd_seq_port_info * info)
339 {
340         snd_assert(port && info, return -EINVAL);
341
342         /* set port name */
343         if (info->name[0])
344                 strlcpy(port->name, info->name, sizeof(port->name));
345         
346         /* set capabilities */
347         port->capability = info->capability;
348         
349         /* get port type */
350         port->type = info->type;
351
352         /* information about supported channels/voices */
353         port->midi_channels = info->midi_channels;
354         port->midi_voices = info->midi_voices;
355         port->synth_voices = info->synth_voices;
356
357         /* timestamping */
358         port->timestamping = (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
359         port->time_real = (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
360         port->time_queue = info->time_queue;
361
362         return 0;
363 }
364
365 /* get port info fields */
366 int snd_seq_get_port_info(struct snd_seq_client_port * port,
367                           struct snd_seq_port_info * info)
368 {
369         snd_assert(port && info, return -EINVAL);
370
371         /* get port name */
372         strlcpy(info->name, port->name, sizeof(info->name));
373         
374         /* get capabilities */
375         info->capability = port->capability;
376
377         /* get port type */
378         info->type = port->type;
379
380         /* information about supported channels/voices */
381         info->midi_channels = port->midi_channels;
382         info->midi_voices = port->midi_voices;
383         info->synth_voices = port->synth_voices;
384
385         /* get subscriber counts */
386         info->read_use = port->c_src.count;
387         info->write_use = port->c_dest.count;
388         
389         /* timestamping */
390         info->flags = 0;
391         if (port->timestamping) {
392                 info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
393                 if (port->time_real)
394                         info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
395                 info->time_queue = port->time_queue;
396         }
397
398         return 0;
399 }
400
401
402
403 /*
404  * call callback functions (if any):
405  * the callbacks are invoked only when the first (for connection) or
406  * the last subscription (for disconnection) is done.  Second or later
407  * subscription results in increment of counter, but no callback is
408  * invoked.
409  * This feature is useful if these callbacks are associated with
410  * initialization or termination of devices (see seq_midi.c).
411  *
412  * If callback_all option is set, the callback function is invoked
413  * at each connnection/disconnection. 
414  */
415
416 static int subscribe_port(struct snd_seq_client *client,
417                           struct snd_seq_client_port *port,
418                           struct snd_seq_port_subs_info *grp,
419                           struct snd_seq_port_subscribe *info,
420                           int send_ack)
421 {
422         int err = 0;
423
424         if (!try_module_get(port->owner))
425                 return -EFAULT;
426         grp->count++;
427         if (grp->open && (port->callback_all || grp->count == 1)) {
428                 err = grp->open(port->private_data, info);
429                 if (err < 0) {
430                         module_put(port->owner);
431                         grp->count--;
432                 }
433         }
434         if (err >= 0 && send_ack && client->type == USER_CLIENT)
435                 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
436                                                    info, SNDRV_SEQ_EVENT_PORT_SUBSCRIBED);
437
438         return err;
439 }
440
441 static int unsubscribe_port(struct snd_seq_client *client,
442                             struct snd_seq_client_port *port,
443                             struct snd_seq_port_subs_info *grp,
444                             struct snd_seq_port_subscribe *info,
445                             int send_ack)
446 {
447         int err = 0;
448
449         if (! grp->count)
450                 return -EINVAL;
451         grp->count--;
452         if (grp->close && (port->callback_all || grp->count == 0))
453                 err = grp->close(port->private_data, info);
454         if (send_ack && client->type == USER_CLIENT)
455                 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
456                                                    info, SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED);
457         module_put(port->owner);
458         return err;
459 }
460
461
462
463 /* check if both addresses are identical */
464 static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s)
465 {
466         return (r->client == s->client) && (r->port == s->port);
467 }
468
469 /* check the two subscribe info match */
470 /* if flags is zero, checks only sender and destination addresses */
471 static int match_subs_info(struct snd_seq_port_subscribe *r,
472                            struct snd_seq_port_subscribe *s)
473 {
474         if (addr_match(&r->sender, &s->sender) &&
475             addr_match(&r->dest, &s->dest)) {
476                 if (r->flags && r->flags == s->flags)
477                         return r->queue == s->queue;
478                 else if (! r->flags)
479                         return 1;
480         }
481         return 0;
482 }
483
484
485 /* connect two ports */
486 int snd_seq_port_connect(struct snd_seq_client *connector,
487                          struct snd_seq_client *src_client,
488                          struct snd_seq_client_port *src_port,
489                          struct snd_seq_client *dest_client,
490                          struct snd_seq_client_port *dest_port,
491                          struct snd_seq_port_subscribe *info)
492 {
493         struct snd_seq_port_subs_info *src = &src_port->c_src;
494         struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
495         struct snd_seq_subscribers *subs, *s;
496         int err, src_called = 0;
497         unsigned long flags;
498         int exclusive;
499
500         subs = kzalloc(sizeof(*subs), GFP_KERNEL);
501         if (! subs)
502                 return -ENOMEM;
503
504         subs->info = *info;
505         atomic_set(&subs->ref_count, 2);
506
507         down_write(&src->list_mutex);
508         down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
509
510         exclusive = info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE ? 1 : 0;
511         err = -EBUSY;
512         if (exclusive) {
513                 if (! list_empty(&src->list_head) || ! list_empty(&dest->list_head))
514                         goto __error;
515         } else {
516                 if (src->exclusive || dest->exclusive)
517                         goto __error;
518                 /* check whether already exists */
519                 list_for_each_entry(s, &src->list_head, src_list) {
520                         if (match_subs_info(info, &s->info))
521                                 goto __error;
522                 }
523                 list_for_each_entry(s, &dest->list_head, dest_list) {
524                         if (match_subs_info(info, &s->info))
525                                 goto __error;
526                 }
527         }
528
529         if ((err = subscribe_port(src_client, src_port, src, info,
530                                   connector->number != src_client->number)) < 0)
531                 goto __error;
532         src_called = 1;
533
534         if ((err = subscribe_port(dest_client, dest_port, dest, info,
535                                   connector->number != dest_client->number)) < 0)
536                 goto __error;
537
538         /* add to list */
539         write_lock_irqsave(&src->list_lock, flags);
540         // write_lock(&dest->list_lock); // no other lock yet
541         list_add_tail(&subs->src_list, &src->list_head);
542         list_add_tail(&subs->dest_list, &dest->list_head);
543         // write_unlock(&dest->list_lock); // no other lock yet
544         write_unlock_irqrestore(&src->list_lock, flags);
545
546         src->exclusive = dest->exclusive = exclusive;
547
548         up_write(&dest->list_mutex);
549         up_write(&src->list_mutex);
550         return 0;
551
552  __error:
553         if (src_called)
554                 unsubscribe_port(src_client, src_port, src, info,
555                                  connector->number != src_client->number);
556         kfree(subs);
557         up_write(&dest->list_mutex);
558         up_write(&src->list_mutex);
559         return err;
560 }
561
562
563 /* remove the connection */
564 int snd_seq_port_disconnect(struct snd_seq_client *connector,
565                             struct snd_seq_client *src_client,
566                             struct snd_seq_client_port *src_port,
567                             struct snd_seq_client *dest_client,
568                             struct snd_seq_client_port *dest_port,
569                             struct snd_seq_port_subscribe *info)
570 {
571         struct snd_seq_port_subs_info *src = &src_port->c_src;
572         struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
573         struct snd_seq_subscribers *subs;
574         int err = -ENOENT;
575         unsigned long flags;
576
577         down_write(&src->list_mutex);
578         down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
579
580         /* look for the connection */
581         list_for_each_entry(subs, &src->list_head, src_list) {
582                 if (match_subs_info(info, &subs->info)) {
583                         write_lock_irqsave(&src->list_lock, flags);
584                         // write_lock(&dest->list_lock);  // no lock yet
585                         list_del(&subs->src_list);
586                         list_del(&subs->dest_list);
587                         // write_unlock(&dest->list_lock);
588                         write_unlock_irqrestore(&src->list_lock, flags);
589                         src->exclusive = dest->exclusive = 0;
590                         unsubscribe_port(src_client, src_port, src, info,
591                                          connector->number != src_client->number);
592                         unsubscribe_port(dest_client, dest_port, dest, info,
593                                          connector->number != dest_client->number);
594                         kfree(subs);
595                         err = 0;
596                         break;
597                 }
598         }
599
600         up_write(&dest->list_mutex);
601         up_write(&src->list_mutex);
602         return err;
603 }
604
605
606 /* get matched subscriber */
607 struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
608                                                           struct snd_seq_addr *dest_addr)
609 {
610         struct snd_seq_subscribers *s, *found = NULL;
611
612         down_read(&src_grp->list_mutex);
613         list_for_each_entry(s, &src_grp->list_head, src_list) {
614                 if (addr_match(dest_addr, &s->info.dest)) {
615                         found = s;
616                         break;
617                 }
618         }
619         up_read(&src_grp->list_mutex);
620         return found;
621 }
622
623 /*
624  * Attach a device driver that wants to receive events from the
625  * sequencer.  Returns the new port number on success.
626  * A driver that wants to receive the events converted to midi, will
627  * use snd_seq_midisynth_register_port().
628  */
629 /* exported */
630 int snd_seq_event_port_attach(int client,
631                               struct snd_seq_port_callback *pcbp,
632                               int cap, int type, int midi_channels,
633                               int midi_voices, char *portname)
634 {
635         struct snd_seq_port_info portinfo;
636         int  ret;
637
638         /* Set up the port */
639         memset(&portinfo, 0, sizeof(portinfo));
640         portinfo.addr.client = client;
641         strlcpy(portinfo.name, portname ? portname : "Unamed port",
642                 sizeof(portinfo.name));
643
644         portinfo.capability = cap;
645         portinfo.type = type;
646         portinfo.kernel = pcbp;
647         portinfo.midi_channels = midi_channels;
648         portinfo.midi_voices = midi_voices;
649
650         /* Create it */
651         ret = snd_seq_kernel_client_ctl(client,
652                                         SNDRV_SEQ_IOCTL_CREATE_PORT,
653                                         &portinfo);
654
655         if (ret >= 0)
656                 ret = portinfo.addr.port;
657
658         return ret;
659 }
660
661 EXPORT_SYMBOL(snd_seq_event_port_attach);
662
663 /*
664  * Detach the driver from a port.
665  */
666 /* exported */
667 int snd_seq_event_port_detach(int client, int port)
668 {
669         struct snd_seq_port_info portinfo;
670         int  err;
671
672         memset(&portinfo, 0, sizeof(portinfo));
673         portinfo.addr.client = client;
674         portinfo.addr.port   = port;
675         err = snd_seq_kernel_client_ctl(client,
676                                         SNDRV_SEQ_IOCTL_DELETE_PORT,
677                                         &portinfo);
678
679         return err;
680 }
681
682 EXPORT_SYMBOL(snd_seq_event_port_detach);