3 * Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
4 * Jaroslav Kysela <perex@perex.cz>
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.
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.
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
23 #include <sound/core.h>
24 #include <linux/slab.h>
25 #include <linux/module.h>
26 #include "seq_system.h"
27 #include "seq_ports.h"
28 #include "seq_clientmgr.h"
32 registration of client ports
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.
47 1) leave it this way, a client does normaly does not have more than a few
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.
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,
62 struct snd_seq_client_port *port;
66 read_lock(&client->ports_lock);
67 list_for_each_entry(port, &client->ports_list_head, list) {
68 if (port->addr.port == num) {
70 break; /* deleting now */
71 snd_use_lock_use(&port->use_lock);
72 read_unlock(&client->ports_lock);
76 read_unlock(&client->ports_lock);
77 return NULL; /* not found */
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)
86 struct snd_seq_client_port *port, *found;
88 num = pinfo->addr.port;
90 read_lock(&client->ports_lock);
91 list_for_each_entry(port, &client->ports_list_head, list) {
92 if (port->addr.port < num)
94 if (port->addr.port == num) {
98 if (found == NULL || port->addr.port < found->addr.port)
105 snd_use_lock_use(&found->use_lock);
107 read_unlock(&client->ports_lock);
112 /* initialize snd_seq_port_subs_info */
113 static void port_subs_info_init(struct snd_seq_port_subs_info *grp)
115 INIT_LIST_HEAD(&grp->list_head);
118 rwlock_init(&grp->list_lock);
119 init_rwsem(&grp->list_mutex);
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,
130 struct snd_seq_client_port *new_port, *p;
134 if (snd_BUG_ON(!client))
137 if (client->num_ports >= SNDRV_SEQ_MAX_PORTS - 1) {
138 snd_printk(KERN_WARNING "too many ports for client %d\n", client->number);
142 /* create a new port */
143 new_port = kzalloc(sizeof(*new_port), GFP_KERNEL);
145 snd_printd("malloc failed for registering client port\n");
146 return NULL; /* failure, out of memory */
149 new_port->addr.client = client->number;
150 new_port->addr.port = -1;
151 new_port->owner = THIS_MODULE;
152 sprintf(new_port->name, "port-%d", num);
153 snd_use_lock_init(&new_port->use_lock);
154 port_subs_info_init(&new_port->c_src);
155 port_subs_info_init(&new_port->c_dest);
157 num = port >= 0 ? port : 0;
158 mutex_lock(&client->ports_mutex);
159 write_lock_irqsave(&client->ports_lock, flags);
160 list_for_each_entry(p, &client->ports_list_head, list) {
161 if (p->addr.port > num)
163 if (port < 0) /* auto-probe mode */
164 num = p->addr.port + 1;
166 /* insert the new port */
167 list_add_tail(&new_port->list, &p->list);
169 new_port->addr.port = num; /* store the port number in the port */
170 write_unlock_irqrestore(&client->ports_lock, flags);
171 mutex_unlock(&client->ports_mutex);
172 sprintf(new_port->name, "port-%d", num);
178 static int subscribe_port(struct snd_seq_client *client,
179 struct snd_seq_client_port *port,
180 struct snd_seq_port_subs_info *grp,
181 struct snd_seq_port_subscribe *info, int send_ack);
182 static int unsubscribe_port(struct snd_seq_client *client,
183 struct snd_seq_client_port *port,
184 struct snd_seq_port_subs_info *grp,
185 struct snd_seq_port_subscribe *info, int send_ack);
188 static struct snd_seq_client_port *get_client_port(struct snd_seq_addr *addr,
189 struct snd_seq_client **cp)
191 struct snd_seq_client_port *p;
192 *cp = snd_seq_client_use_ptr(addr->client);
194 p = snd_seq_port_use_ptr(*cp, addr->port);
196 snd_seq_client_unlock(*cp);
204 static void delete_and_unsubscribe_port(struct snd_seq_client *client,
205 struct snd_seq_client_port *port,
206 struct snd_seq_subscribers *subs,
207 bool is_src, bool ack);
209 static inline struct snd_seq_subscribers *
210 get_subscriber(struct list_head *p, bool is_src)
213 return list_entry(p, struct snd_seq_subscribers, src_list);
215 return list_entry(p, struct snd_seq_subscribers, dest_list);
219 * remove all subscribers on the list
220 * this is called from port_delete, for each src and dest list.
222 static void clear_subscriber_list(struct snd_seq_client *client,
223 struct snd_seq_client_port *port,
224 struct snd_seq_port_subs_info *grp,
227 struct list_head *p, *n;
229 list_for_each_safe(p, n, &grp->list_head) {
230 struct snd_seq_subscribers *subs;
231 struct snd_seq_client *c;
232 struct snd_seq_client_port *aport;
234 subs = get_subscriber(p, is_src);
236 aport = get_client_port(&subs->info.dest, &c);
238 aport = get_client_port(&subs->info.sender, &c);
239 delete_and_unsubscribe_port(client, port, subs, is_src, false);
242 /* looks like the connected port is being deleted.
243 * we decrease the counter, and when both ports are deleted
244 * remove the subscriber info
246 if (atomic_dec_and_test(&subs->ref_count))
251 /* ok we got the connected port */
252 delete_and_unsubscribe_port(c, aport, subs, !is_src, true);
254 snd_seq_port_unlock(aport);
255 snd_seq_client_unlock(c);
259 /* delete port data */
260 static int port_delete(struct snd_seq_client *client,
261 struct snd_seq_client_port *port)
263 /* set closing flag and wait for all port access are gone */
265 snd_use_lock_sync(&port->use_lock);
267 /* clear subscribers info */
268 clear_subscriber_list(client, port, &port->c_src, true);
269 clear_subscriber_list(client, port, &port->c_dest, false);
271 if (port->private_free)
272 port->private_free(port->private_data);
274 snd_BUG_ON(port->c_src.count != 0);
275 snd_BUG_ON(port->c_dest.count != 0);
282 /* delete a port with the given port id */
283 int snd_seq_delete_port(struct snd_seq_client *client, int port)
286 struct snd_seq_client_port *found = NULL, *p;
288 mutex_lock(&client->ports_mutex);
289 write_lock_irqsave(&client->ports_lock, flags);
290 list_for_each_entry(p, &client->ports_list_head, list) {
291 if (p->addr.port == port) {
292 /* ok found. delete from the list at first */
299 write_unlock_irqrestore(&client->ports_lock, flags);
300 mutex_unlock(&client->ports_mutex);
302 return port_delete(client, found);
307 /* delete the all ports belonging to the given client */
308 int snd_seq_delete_all_ports(struct snd_seq_client *client)
311 struct list_head deleted_list;
312 struct snd_seq_client_port *port, *tmp;
314 /* move the port list to deleted_list, and
315 * clear the port list in the client data.
317 mutex_lock(&client->ports_mutex);
318 write_lock_irqsave(&client->ports_lock, flags);
319 if (! list_empty(&client->ports_list_head)) {
320 list_add(&deleted_list, &client->ports_list_head);
321 list_del_init(&client->ports_list_head);
323 INIT_LIST_HEAD(&deleted_list);
325 client->num_ports = 0;
326 write_unlock_irqrestore(&client->ports_lock, flags);
328 /* remove each port in deleted_list */
329 list_for_each_entry_safe(port, tmp, &deleted_list, list) {
330 list_del(&port->list);
331 snd_seq_system_client_ev_port_exit(port->addr.client, port->addr.port);
332 port_delete(client, port);
334 mutex_unlock(&client->ports_mutex);
338 /* set port info fields */
339 int snd_seq_set_port_info(struct snd_seq_client_port * port,
340 struct snd_seq_port_info * info)
342 if (snd_BUG_ON(!port || !info))
347 strlcpy(port->name, info->name, sizeof(port->name));
349 /* set capabilities */
350 port->capability = info->capability;
353 port->type = info->type;
355 /* information about supported channels/voices */
356 port->midi_channels = info->midi_channels;
357 port->midi_voices = info->midi_voices;
358 port->synth_voices = info->synth_voices;
361 port->timestamping = (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
362 port->time_real = (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
363 port->time_queue = info->time_queue;
368 /* get port info fields */
369 int snd_seq_get_port_info(struct snd_seq_client_port * port,
370 struct snd_seq_port_info * info)
372 if (snd_BUG_ON(!port || !info))
376 strlcpy(info->name, port->name, sizeof(info->name));
378 /* get capabilities */
379 info->capability = port->capability;
382 info->type = port->type;
384 /* information about supported channels/voices */
385 info->midi_channels = port->midi_channels;
386 info->midi_voices = port->midi_voices;
387 info->synth_voices = port->synth_voices;
389 /* get subscriber counts */
390 info->read_use = port->c_src.count;
391 info->write_use = port->c_dest.count;
395 if (port->timestamping) {
396 info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
398 info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
399 info->time_queue = port->time_queue;
408 * call callback functions (if any):
409 * the callbacks are invoked only when the first (for connection) or
410 * the last subscription (for disconnection) is done. Second or later
411 * subscription results in increment of counter, but no callback is
413 * This feature is useful if these callbacks are associated with
414 * initialization or termination of devices (see seq_midi.c).
416 * If callback_all option is set, the callback function is invoked
417 * at each connection/disconnection.
420 static int subscribe_port(struct snd_seq_client *client,
421 struct snd_seq_client_port *port,
422 struct snd_seq_port_subs_info *grp,
423 struct snd_seq_port_subscribe *info,
428 if (!try_module_get(port->owner))
431 if (grp->open && (port->callback_all || grp->count == 1)) {
432 err = grp->open(port->private_data, info);
434 module_put(port->owner);
438 if (err >= 0 && send_ack && client->type == USER_CLIENT)
439 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
440 info, SNDRV_SEQ_EVENT_PORT_SUBSCRIBED);
445 static int unsubscribe_port(struct snd_seq_client *client,
446 struct snd_seq_client_port *port,
447 struct snd_seq_port_subs_info *grp,
448 struct snd_seq_port_subscribe *info,
456 if (grp->close && (port->callback_all || grp->count == 0))
457 err = grp->close(port->private_data, info);
458 if (send_ack && client->type == USER_CLIENT)
459 snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
460 info, SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED);
461 module_put(port->owner);
467 /* check if both addresses are identical */
468 static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s)
470 return (r->client == s->client) && (r->port == s->port);
473 /* check the two subscribe info match */
474 /* if flags is zero, checks only sender and destination addresses */
475 static int match_subs_info(struct snd_seq_port_subscribe *r,
476 struct snd_seq_port_subscribe *s)
478 if (addr_match(&r->sender, &s->sender) &&
479 addr_match(&r->dest, &s->dest)) {
480 if (r->flags && r->flags == s->flags)
481 return r->queue == s->queue;
488 static int check_and_subscribe_port(struct snd_seq_client *client,
489 struct snd_seq_client_port *port,
490 struct snd_seq_subscribers *subs,
491 bool is_src, bool exclusive, bool ack)
493 struct snd_seq_port_subs_info *grp;
495 struct snd_seq_subscribers *s;
498 grp = is_src ? &port->c_src : &port->c_dest;
500 down_write(&grp->list_mutex);
502 if (!list_empty(&grp->list_head))
507 /* check whether already exists */
508 list_for_each(p, &grp->list_head) {
509 s = get_subscriber(p, is_src);
510 if (match_subs_info(&subs->info, &s->info))
515 err = subscribe_port(client, port, grp, &subs->info, ack);
522 write_lock_irq(&grp->list_lock);
524 list_add_tail(&subs->src_list, &grp->list_head);
526 list_add_tail(&subs->dest_list, &grp->list_head);
527 grp->exclusive = exclusive;
528 atomic_inc(&subs->ref_count);
529 write_unlock_irq(&grp->list_lock);
533 up_write(&grp->list_mutex);
537 static void delete_and_unsubscribe_port(struct snd_seq_client *client,
538 struct snd_seq_client_port *port,
539 struct snd_seq_subscribers *subs,
540 bool is_src, bool ack)
542 struct snd_seq_port_subs_info *grp;
543 struct list_head *list;
546 grp = is_src ? &port->c_src : &port->c_dest;
547 list = is_src ? &subs->src_list : &subs->dest_list;
548 down_write(&grp->list_mutex);
549 write_lock_irq(&grp->list_lock);
550 empty = list_empty(list);
554 write_unlock_irq(&grp->list_lock);
555 up_write(&grp->list_mutex);
558 unsubscribe_port(client, port, grp, &subs->info, ack);
561 /* connect two ports */
562 int snd_seq_port_connect(struct snd_seq_client *connector,
563 struct snd_seq_client *src_client,
564 struct snd_seq_client_port *src_port,
565 struct snd_seq_client *dest_client,
566 struct snd_seq_client_port *dest_port,
567 struct snd_seq_port_subscribe *info)
569 struct snd_seq_subscribers *subs;
573 subs = kzalloc(sizeof(*subs), GFP_KERNEL);
578 atomic_set(&subs->ref_count, 0);
579 INIT_LIST_HEAD(&subs->src_list);
580 INIT_LIST_HEAD(&subs->dest_list);
582 exclusive = !!(info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE);
584 err = check_and_subscribe_port(src_client, src_port, subs, true,
586 connector->number != src_client->number);
589 err = check_and_subscribe_port(dest_client, dest_port, subs, false,
591 connector->number != dest_client->number);
598 delete_and_unsubscribe_port(src_client, src_port, subs, true,
599 connector->number != src_client->number);
605 /* remove the connection */
606 int snd_seq_port_disconnect(struct snd_seq_client *connector,
607 struct snd_seq_client *src_client,
608 struct snd_seq_client_port *src_port,
609 struct snd_seq_client *dest_client,
610 struct snd_seq_client_port *dest_port,
611 struct snd_seq_port_subscribe *info)
613 struct snd_seq_port_subs_info *src = &src_port->c_src;
614 struct snd_seq_subscribers *subs;
617 down_write(&src->list_mutex);
618 /* look for the connection */
619 list_for_each_entry(subs, &src->list_head, src_list) {
620 if (match_subs_info(info, &subs->info)) {
621 atomic_dec(&subs->ref_count); /* mark as not ready */
626 up_write(&src->list_mutex);
630 delete_and_unsubscribe_port(src_client, src_port, subs, true,
631 connector->number != src_client->number);
632 delete_and_unsubscribe_port(dest_client, dest_port, subs, false,
633 connector->number != dest_client->number);
639 /* get matched subscriber */
640 struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
641 struct snd_seq_addr *dest_addr)
643 struct snd_seq_subscribers *s, *found = NULL;
645 down_read(&src_grp->list_mutex);
646 list_for_each_entry(s, &src_grp->list_head, src_list) {
647 if (addr_match(dest_addr, &s->info.dest)) {
652 up_read(&src_grp->list_mutex);
657 * Attach a device driver that wants to receive events from the
658 * sequencer. Returns the new port number on success.
659 * A driver that wants to receive the events converted to midi, will
660 * use snd_seq_midisynth_register_port().
663 int snd_seq_event_port_attach(int client,
664 struct snd_seq_port_callback *pcbp,
665 int cap, int type, int midi_channels,
666 int midi_voices, char *portname)
668 struct snd_seq_port_info portinfo;
671 /* Set up the port */
672 memset(&portinfo, 0, sizeof(portinfo));
673 portinfo.addr.client = client;
674 strlcpy(portinfo.name, portname ? portname : "Unamed port",
675 sizeof(portinfo.name));
677 portinfo.capability = cap;
678 portinfo.type = type;
679 portinfo.kernel = pcbp;
680 portinfo.midi_channels = midi_channels;
681 portinfo.midi_voices = midi_voices;
684 ret = snd_seq_kernel_client_ctl(client,
685 SNDRV_SEQ_IOCTL_CREATE_PORT,
689 ret = portinfo.addr.port;
694 EXPORT_SYMBOL(snd_seq_event_port_attach);
697 * Detach the driver from a port.
700 int snd_seq_event_port_detach(int client, int port)
702 struct snd_seq_port_info portinfo;
705 memset(&portinfo, 0, sizeof(portinfo));
706 portinfo.addr.client = client;
707 portinfo.addr.port = port;
708 err = snd_seq_kernel_client_ctl(client,
709 SNDRV_SEQ_IOCTL_DELETE_PORT,
715 EXPORT_SYMBOL(snd_seq_event_port_detach);