• Home
  • History
  • Annotate
  • Line#
  • Navigate
  • Raw
  • Download
  • only in /asuswrt-rt-n18u-9.0.0.4.380.2695/release/src-rt-6.x.4708/linux/linux-2.6.36/sound/core/seq/
1/*
2 *   ALSA sequencer Ports
3 *   Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
4 *                         Jaroslav Kysela <perex@perex.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/core.h>
24#include <linux/slab.h>
25#include "seq_system.h"
26#include "seq_ports.h"
27#include "seq_clientmgr.h"
28
29/*
30
31   registration of client ports
32
33 */
34
35
36/*
37
38NOTE: the current implementation of the port structure as a linked list is
39not optimal for clients that have many ports. For sending messages to all
40subscribers of a port we first need to find the address of the port
41structure, which means we have to traverse the list. A direct access table
42(array) would be better, but big preallocated arrays waste memory.
43
44Possible actions:
45
461) leave it this way, a client does normaly does not have more than a few
47ports
48
492) replace the linked list of ports by a array of pointers which is
50dynamicly kmalloced. When a port is added or deleted we can simply allocate
51a new array, copy the corresponding pointers, and delete the old one. We
52then only need a pointer to this array, and an integer that tells us how
53much elements are in array.
54
55*/
56
57/* return pointer to port structure - port is locked if found */
58struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client,
59						 int num)
60{
61	struct snd_seq_client_port *port;
62
63	if (client == NULL)
64		return NULL;
65	read_lock(&client->ports_lock);
66	list_for_each_entry(port, &client->ports_list_head, list) {
67		if (port->addr.port == num) {
68			if (port->closing)
69				break; /* deleting now */
70			snd_use_lock_use(&port->use_lock);
71			read_unlock(&client->ports_lock);
72			return port;
73		}
74	}
75	read_unlock(&client->ports_lock);
76	return NULL;		/* not found */
77}
78
79
80/* search for the next port - port is locked if found */
81struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
82						       struct snd_seq_port_info *pinfo)
83{
84	int num;
85	struct snd_seq_client_port *port, *found;
86
87	num = pinfo->addr.port;
88	found = NULL;
89	read_lock(&client->ports_lock);
90	list_for_each_entry(port, &client->ports_list_head, list) {
91		if (port->addr.port < num)
92			continue;
93		if (port->addr.port == num) {
94			found = port;
95			break;
96		}
97		if (found == NULL || port->addr.port < found->addr.port)
98			found = port;
99	}
100	if (found) {
101		if (found->closing)
102			found = NULL;
103		else
104			snd_use_lock_use(&found->use_lock);
105	}
106	read_unlock(&client->ports_lock);
107	return found;
108}
109
110
111/* initialize snd_seq_port_subs_info */
112static void port_subs_info_init(struct snd_seq_port_subs_info *grp)
113{
114	INIT_LIST_HEAD(&grp->list_head);
115	grp->count = 0;
116	grp->exclusive = 0;
117	rwlock_init(&grp->list_lock);
118	init_rwsem(&grp->list_mutex);
119	grp->open = NULL;
120	grp->close = NULL;
121}
122
123
124/* create a port, port number is returned (-1 on failure) */
125struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client,
126						int port)
127{
128	unsigned long flags;
129	struct snd_seq_client_port *new_port, *p;
130	int num = -1;
131
132	/* sanity check */
133	if (snd_BUG_ON(!client))
134		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/* */
177enum group_type {
178	SRC_LIST, DEST_LIST
179};
180
181static 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);
185static 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
191static 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 */
211static 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 */
258static 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_BUG_ON(port->c_src.count != 0);
273	snd_BUG_ON(port->c_dest.count != 0);
274
275	kfree(port);
276	return 0;
277}
278
279
280/* delete a port with the given port id */
281int 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 */
306int 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 */
337int snd_seq_set_port_info(struct snd_seq_client_port * port,
338			  struct snd_seq_port_info * info)
339{
340	if (snd_BUG_ON(!port || !info))
341		return -EINVAL;
342
343	/* set port name */
344	if (info->name[0])
345		strlcpy(port->name, info->name, sizeof(port->name));
346
347	/* set capabilities */
348	port->capability = info->capability;
349
350	/* get port type */
351	port->type = info->type;
352
353	/* information about supported channels/voices */
354	port->midi_channels = info->midi_channels;
355	port->midi_voices = info->midi_voices;
356	port->synth_voices = info->synth_voices;
357
358	/* timestamping */
359	port->timestamping = (info->flags & SNDRV_SEQ_PORT_FLG_TIMESTAMP) ? 1 : 0;
360	port->time_real = (info->flags & SNDRV_SEQ_PORT_FLG_TIME_REAL) ? 1 : 0;
361	port->time_queue = info->time_queue;
362
363	return 0;
364}
365
366/* get port info fields */
367int snd_seq_get_port_info(struct snd_seq_client_port * port,
368			  struct snd_seq_port_info * info)
369{
370	if (snd_BUG_ON(!port || !info))
371		return -EINVAL;
372
373	/* get port name */
374	strlcpy(info->name, port->name, sizeof(info->name));
375
376	/* get capabilities */
377	info->capability = port->capability;
378
379	/* get port type */
380	info->type = port->type;
381
382	/* information about supported channels/voices */
383	info->midi_channels = port->midi_channels;
384	info->midi_voices = port->midi_voices;
385	info->synth_voices = port->synth_voices;
386
387	/* get subscriber counts */
388	info->read_use = port->c_src.count;
389	info->write_use = port->c_dest.count;
390
391	/* timestamping */
392	info->flags = 0;
393	if (port->timestamping) {
394		info->flags |= SNDRV_SEQ_PORT_FLG_TIMESTAMP;
395		if (port->time_real)
396			info->flags |= SNDRV_SEQ_PORT_FLG_TIME_REAL;
397		info->time_queue = port->time_queue;
398	}
399
400	return 0;
401}
402
403
404
405/*
406 * call callback functions (if any):
407 * the callbacks are invoked only when the first (for connection) or
408 * the last subscription (for disconnection) is done.  Second or later
409 * subscription results in increment of counter, but no callback is
410 * invoked.
411 * This feature is useful if these callbacks are associated with
412 * initialization or termination of devices (see seq_midi.c).
413 *
414 * If callback_all option is set, the callback function is invoked
415 * at each connnection/disconnection.
416 */
417
418static int subscribe_port(struct snd_seq_client *client,
419			  struct snd_seq_client_port *port,
420			  struct snd_seq_port_subs_info *grp,
421			  struct snd_seq_port_subscribe *info,
422			  int send_ack)
423{
424	int err = 0;
425
426	if (!try_module_get(port->owner))
427		return -EFAULT;
428	grp->count++;
429	if (grp->open && (port->callback_all || grp->count == 1)) {
430		err = grp->open(port->private_data, info);
431		if (err < 0) {
432			module_put(port->owner);
433			grp->count--;
434		}
435	}
436	if (err >= 0 && send_ack && client->type == USER_CLIENT)
437		snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
438						   info, SNDRV_SEQ_EVENT_PORT_SUBSCRIBED);
439
440	return err;
441}
442
443static int unsubscribe_port(struct snd_seq_client *client,
444			    struct snd_seq_client_port *port,
445			    struct snd_seq_port_subs_info *grp,
446			    struct snd_seq_port_subscribe *info,
447			    int send_ack)
448{
449	int err = 0;
450
451	if (! grp->count)
452		return -EINVAL;
453	grp->count--;
454	if (grp->close && (port->callback_all || grp->count == 0))
455		err = grp->close(port->private_data, info);
456	if (send_ack && client->type == USER_CLIENT)
457		snd_seq_client_notify_subscription(port->addr.client, port->addr.port,
458						   info, SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED);
459	module_put(port->owner);
460	return err;
461}
462
463
464
465/* check if both addresses are identical */
466static inline int addr_match(struct snd_seq_addr *r, struct snd_seq_addr *s)
467{
468	return (r->client == s->client) && (r->port == s->port);
469}
470
471/* check the two subscribe info match */
472/* if flags is zero, checks only sender and destination addresses */
473static int match_subs_info(struct snd_seq_port_subscribe *r,
474			   struct snd_seq_port_subscribe *s)
475{
476	if (addr_match(&r->sender, &s->sender) &&
477	    addr_match(&r->dest, &s->dest)) {
478		if (r->flags && r->flags == s->flags)
479			return r->queue == s->queue;
480		else if (! r->flags)
481			return 1;
482	}
483	return 0;
484}
485
486
487/* connect two ports */
488int snd_seq_port_connect(struct snd_seq_client *connector,
489			 struct snd_seq_client *src_client,
490			 struct snd_seq_client_port *src_port,
491			 struct snd_seq_client *dest_client,
492			 struct snd_seq_client_port *dest_port,
493			 struct snd_seq_port_subscribe *info)
494{
495	struct snd_seq_port_subs_info *src = &src_port->c_src;
496	struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
497	struct snd_seq_subscribers *subs, *s;
498	int err, src_called = 0;
499	unsigned long flags;
500	int exclusive;
501
502	subs = kzalloc(sizeof(*subs), GFP_KERNEL);
503	if (! subs)
504		return -ENOMEM;
505
506	subs->info = *info;
507	atomic_set(&subs->ref_count, 2);
508
509	down_write(&src->list_mutex);
510	down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
511
512	exclusive = info->flags & SNDRV_SEQ_PORT_SUBS_EXCLUSIVE ? 1 : 0;
513	err = -EBUSY;
514	if (exclusive) {
515		if (! list_empty(&src->list_head) || ! list_empty(&dest->list_head))
516			goto __error;
517	} else {
518		if (src->exclusive || dest->exclusive)
519			goto __error;
520		/* check whether already exists */
521		list_for_each_entry(s, &src->list_head, src_list) {
522			if (match_subs_info(info, &s->info))
523				goto __error;
524		}
525		list_for_each_entry(s, &dest->list_head, dest_list) {
526			if (match_subs_info(info, &s->info))
527				goto __error;
528		}
529	}
530
531	if ((err = subscribe_port(src_client, src_port, src, info,
532				  connector->number != src_client->number)) < 0)
533		goto __error;
534	src_called = 1;
535
536	if ((err = subscribe_port(dest_client, dest_port, dest, info,
537				  connector->number != dest_client->number)) < 0)
538		goto __error;
539
540	/* add to list */
541	write_lock_irqsave(&src->list_lock, flags);
542	// write_lock(&dest->list_lock); // no other lock yet
543	list_add_tail(&subs->src_list, &src->list_head);
544	list_add_tail(&subs->dest_list, &dest->list_head);
545	// write_unlock(&dest->list_lock); // no other lock yet
546	write_unlock_irqrestore(&src->list_lock, flags);
547
548	src->exclusive = dest->exclusive = exclusive;
549
550	up_write(&dest->list_mutex);
551	up_write(&src->list_mutex);
552	return 0;
553
554 __error:
555	if (src_called)
556		unsubscribe_port(src_client, src_port, src, info,
557				 connector->number != src_client->number);
558	kfree(subs);
559	up_write(&dest->list_mutex);
560	up_write(&src->list_mutex);
561	return err;
562}
563
564
565/* remove the connection */
566int snd_seq_port_disconnect(struct snd_seq_client *connector,
567			    struct snd_seq_client *src_client,
568			    struct snd_seq_client_port *src_port,
569			    struct snd_seq_client *dest_client,
570			    struct snd_seq_client_port *dest_port,
571			    struct snd_seq_port_subscribe *info)
572{
573	struct snd_seq_port_subs_info *src = &src_port->c_src;
574	struct snd_seq_port_subs_info *dest = &dest_port->c_dest;
575	struct snd_seq_subscribers *subs;
576	int err = -ENOENT;
577	unsigned long flags;
578
579	down_write(&src->list_mutex);
580	down_write_nested(&dest->list_mutex, SINGLE_DEPTH_NESTING);
581
582	/* look for the connection */
583	list_for_each_entry(subs, &src->list_head, src_list) {
584		if (match_subs_info(info, &subs->info)) {
585			write_lock_irqsave(&src->list_lock, flags);
586			// write_lock(&dest->list_lock);  // no lock yet
587			list_del(&subs->src_list);
588			list_del(&subs->dest_list);
589			// write_unlock(&dest->list_lock);
590			write_unlock_irqrestore(&src->list_lock, flags);
591			src->exclusive = dest->exclusive = 0;
592			unsubscribe_port(src_client, src_port, src, info,
593					 connector->number != src_client->number);
594			unsubscribe_port(dest_client, dest_port, dest, info,
595					 connector->number != dest_client->number);
596			kfree(subs);
597			err = 0;
598			break;
599		}
600	}
601
602	up_write(&dest->list_mutex);
603	up_write(&src->list_mutex);
604	return err;
605}
606
607
608/* get matched subscriber */
609struct snd_seq_subscribers *snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
610							  struct snd_seq_addr *dest_addr)
611{
612	struct snd_seq_subscribers *s, *found = NULL;
613
614	down_read(&src_grp->list_mutex);
615	list_for_each_entry(s, &src_grp->list_head, src_list) {
616		if (addr_match(dest_addr, &s->info.dest)) {
617			found = s;
618			break;
619		}
620	}
621	up_read(&src_grp->list_mutex);
622	return found;
623}
624
625/*
626 * Attach a device driver that wants to receive events from the
627 * sequencer.  Returns the new port number on success.
628 * A driver that wants to receive the events converted to midi, will
629 * use snd_seq_midisynth_register_port().
630 */
631/* exported */
632int snd_seq_event_port_attach(int client,
633			      struct snd_seq_port_callback *pcbp,
634			      int cap, int type, int midi_channels,
635			      int midi_voices, char *portname)
636{
637	struct snd_seq_port_info portinfo;
638	int  ret;
639
640	/* Set up the port */
641	memset(&portinfo, 0, sizeof(portinfo));
642	portinfo.addr.client = client;
643	strlcpy(portinfo.name, portname ? portname : "Unamed port",
644		sizeof(portinfo.name));
645
646	portinfo.capability = cap;
647	portinfo.type = type;
648	portinfo.kernel = pcbp;
649	portinfo.midi_channels = midi_channels;
650	portinfo.midi_voices = midi_voices;
651
652	/* Create it */
653	ret = snd_seq_kernel_client_ctl(client,
654					SNDRV_SEQ_IOCTL_CREATE_PORT,
655					&portinfo);
656
657	if (ret >= 0)
658		ret = portinfo.addr.port;
659
660	return ret;
661}
662
663EXPORT_SYMBOL(snd_seq_event_port_attach);
664
665/*
666 * Detach the driver from a port.
667 */
668/* exported */
669int snd_seq_event_port_detach(int client, int port)
670{
671	struct snd_seq_port_info portinfo;
672	int  err;
673
674	memset(&portinfo, 0, sizeof(portinfo));
675	portinfo.addr.client = client;
676	portinfo.addr.port   = port;
677	err = snd_seq_kernel_client_ctl(client,
678					SNDRV_SEQ_IOCTL_DELETE_PORT,
679					&portinfo);
680
681	return err;
682}
683
684EXPORT_SYMBOL(snd_seq_event_port_detach);
685