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