[linux-block.git] / sound / core / seq / seq_ports.h

/*
 *   ALSA sequencer Ports 
 *   Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */
#ifndef __SND_SEQ_PORTS_H
#define __SND_SEQ_PORTS_H

#include <sound/seq_kernel.h>
#include "seq_lock.h"

/* list of 'exported' ports */

/* Client ports that are not exported are still accessible, but are
 anonymous ports. 
 
 If a port supports SUBSCRIPTION, that port can send events to all
 subscribersto a special address, with address
 (queue==SNDRV_SEQ_ADDRESS_SUBSCRIBERS). The message is then send to all
 recipients that are registered in the subscription list. A typical
 application for these SUBSCRIPTION events is handling of incoming MIDI
 data. The port doesn't 'know' what other clients are interested in this
 message. If for instance a MIDI recording application would like to receive
 the events from that port, it will first have to subscribe with that port.
 
*/

struct snd_seq_subscribers {
	struct snd_seq_port_subscribe info;	/* additional info */
	struct list_head src_list;	/* link of sources */
	struct list_head dest_list;	/* link of destinations */
	atomic_t ref_count;
};

struct snd_seq_port_subs_info {
	struct list_head list_head;	/* list of subscribed ports */
	unsigned int count;		/* count of subscribers */
	unsigned int exclusive: 1;	/* exclusive mode */
	struct rw_semaphore list_mutex;
	rwlock_t list_lock;
	int (*open)(void *private_data, struct snd_seq_port_subscribe *info);
	int (*close)(void *private_data, struct snd_seq_port_subscribe *info);
};

struct snd_seq_client_port {

	struct snd_seq_addr addr;	/* client/port number */
	struct module *owner;		/* owner of this port */
	char name[64];			/* port name */	
	struct list_head list;		/* port list */
	snd_use_lock_t use_lock;

	/* subscribers */
	struct snd_seq_port_subs_info c_src;	/* read (sender) list */
	struct snd_seq_port_subs_info c_dest;	/* write (dest) list */

	int (*event_input)(struct snd_seq_event *ev, int direct, void *private_data,
			   int atomic, int hop);
	void (*private_free)(void *private_data);
	void *private_data;
	unsigned int closing : 1;
	unsigned int timestamping: 1;
	unsigned int time_real: 1;
	int time_queue;
	
	/* capability, inport, output, sync */
	unsigned int capability;	/* port capability bits */
	unsigned int type;		/* port type bits */

	/* supported channels */
	int midi_channels;
	int midi_voices;
	int synth_voices;
		
};

struct snd_seq_client;

/* return pointer to port structure and lock port */
struct snd_seq_client_port *snd_seq_port_use_ptr(struct snd_seq_client *client, int num);

/* search for next port - port is locked if found */
struct snd_seq_client_port *snd_seq_port_query_nearest(struct snd_seq_client *client,
						       struct snd_seq_port_info *pinfo);

/* unlock the port */
#define snd_seq_port_unlock(port) snd_use_lock_free(&(port)->use_lock)

/* create a port, port number is returned (-1 on failure) */
struct snd_seq_client_port *snd_seq_create_port(struct snd_seq_client *client, int port_index);

/* delete a port */
int snd_seq_delete_port(struct snd_seq_client *client, int port);

/* delete all ports */
int snd_seq_delete_all_ports(struct snd_seq_client *client);

/* set port info fields */
int snd_seq_set_port_info(struct snd_seq_client_port *port,
			  struct snd_seq_port_info *info);

/* get port info fields */
int snd_seq_get_port_info(struct snd_seq_client_port *port,
			  struct snd_seq_port_info *info);

/* add subscriber to subscription list */
int snd_seq_port_connect(struct snd_seq_client *caller,
			 struct snd_seq_client *s, struct snd_seq_client_port *sp,
			 struct snd_seq_client *d, struct snd_seq_client_port *dp,
			 struct snd_seq_port_subscribe *info);

/* remove subscriber from subscription list */ 
int snd_seq_port_disconnect(struct snd_seq_client *caller,
			    struct snd_seq_client *s, struct snd_seq_client_port *sp,
			    struct snd_seq_client *d, struct snd_seq_client_port *dp,
			    struct snd_seq_port_subscribe *info);

/* subscribe port */
int snd_seq_port_subscribe(struct snd_seq_client_port *port,
			   struct snd_seq_port_subscribe *info);

/* get matched subscriber */
int 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);

#endif
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ALSA sequencer Ports
	3	* Copyright (c) 1998 by Frank van de Pol <fvdpol@coil.demon.nl>
	4	*
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21	#ifndef __SND_SEQ_PORTS_H
	22	#define __SND_SEQ_PORTS_H
	23
	24	#include <sound/seq_kernel.h>
	25	#include "seq_lock.h"
	26
	27	/* list of 'exported' ports */
	28
	29	/* Client ports that are not exported are still accessible, but are
	30	anonymous ports.
	31
	32	If a port supports SUBSCRIPTION, that port can send events to all
	33	subscribersto a special address, with address
	34	(queue==SNDRV_SEQ_ADDRESS_SUBSCRIBERS). The message is then send to all
	35	recipients that are registered in the subscription list. A typical
	36	application for these SUBSCRIPTION events is handling of incoming MIDI
	37	data. The port doesn't 'know' what other clients are interested in this
	38	message. If for instance a MIDI recording application would like to receive
	39	the events from that port, it will first have to subscribe with that port.
	40
	41	*/
	42
c7e0b5bf TI	43	struct snd_seq_subscribers {
c7e0b5bf TI	44	struct snd_seq_port_subscribe info; /* additional info */
1da177e4 LT	45	struct list_head src_list; /* link of sources */
	46	struct list_head dest_list; /* link of destinations */
	47	atomic_t ref_count;
c7e0b5bf	48	};
1da177e4	49
c7e0b5bf	50	struct snd_seq_port_subs_info {
1da177e4 LT	51	struct list_head list_head; /* list of subscribed ports */
	52	unsigned int count; /* count of subscribers */
	53	unsigned int exclusive: 1; /* exclusive mode */
	54	struct rw_semaphore list_mutex;
	55	rwlock_t list_lock;
c7e0b5bf TI	56	int (open)(void private_data, struct snd_seq_port_subscribe *info);
	57	int (close)(void private_data, struct snd_seq_port_subscribe *info);
	58	};
1da177e4	59
c7e0b5bf	60	struct snd_seq_client_port {
1da177e4	61
c7e0b5bf	62	struct snd_seq_addr addr; /* client/port number */
1da177e4 LT	63	struct module owner; / owner of this port */
	64	char name[64]; /* port name */
	65	struct list_head list; /* port list */
	66	snd_use_lock_t use_lock;
	67
	68	/* subscribers */
c7e0b5bf TI	69	struct snd_seq_port_subs_info c_src; /* read (sender) list */
c7e0b5bf TI	70	struct snd_seq_port_subs_info c_dest; /* write (dest) list */
1da177e4	71
c7e0b5bf TI	72	int (event_input)(struct snd_seq_event ev, int direct, void *private_data,
	73	int atomic, int hop);
	74	void (private_free)(void private_data);
1da177e4	75	void *private_data;
1da177e4 LT	76	unsigned int closing : 1;
	77	unsigned int timestamping: 1;
	78	unsigned int time_real: 1;
	79	int time_queue;
	80
	81	/* capability, inport, output, sync */
	82	unsigned int capability; /* port capability bits */
	83	unsigned int type; /* port type bits */
	84
	85	/* supported channels */
	86	int midi_channels;
	87	int midi_voices;
	88	int synth_voices;
	89
c7e0b5bf TI	90	};
	91
	92	struct snd_seq_client;
1da177e4 LT	93
1da177e4 LT	94	/* return pointer to port structure and lock port */
c7e0b5bf	95	struct snd_seq_client_port snd_seq_port_use_ptr(struct snd_seq_client client, int num);
1da177e4 LT	96
1da177e4 LT	97	/* search for next port - port is locked if found */
c7e0b5bf TI	98	struct snd_seq_client_port snd_seq_port_query_nearest(struct snd_seq_client client,
c7e0b5bf TI	99	struct snd_seq_port_info *pinfo);
1da177e4 LT	100
	101	/* unlock the port */
	102	#define snd_seq_port_unlock(port) snd_use_lock_free(&(port)->use_lock)
	103
	104	/* create a port, port number is returned (-1 on failure) */
c7e0b5bf	105	struct snd_seq_client_port snd_seq_create_port(struct snd_seq_client client, int port_index);
1da177e4 LT	106
1da177e4 LT	107	/* delete a port */
c7e0b5bf	108	int snd_seq_delete_port(struct snd_seq_client *client, int port);
1da177e4 LT	109
1da177e4 LT	110	/* delete all ports */
c7e0b5bf	111	int snd_seq_delete_all_ports(struct snd_seq_client *client);
1da177e4 LT	112
1da177e4 LT	113	/* set port info fields */
c7e0b5bf TI	114	int snd_seq_set_port_info(struct snd_seq_client_port *port,
c7e0b5bf TI	115	struct snd_seq_port_info *info);
1da177e4 LT	116
1da177e4 LT	117	/* get port info fields */
c7e0b5bf TI	118	int snd_seq_get_port_info(struct snd_seq_client_port *port,
c7e0b5bf TI	119	struct snd_seq_port_info *info);
1da177e4 LT	120
1da177e4 LT	121	/* add subscriber to subscription list */
c7e0b5bf TI	122	int snd_seq_port_connect(struct snd_seq_client *caller,
	123	struct snd_seq_client s, struct snd_seq_client_port sp,
	124	struct snd_seq_client d, struct snd_seq_client_port dp,
	125	struct snd_seq_port_subscribe *info);
1da177e4 LT	126
1da177e4 LT	127	/* remove subscriber from subscription list */
c7e0b5bf TI	128	int snd_seq_port_disconnect(struct snd_seq_client *caller,
	129	struct snd_seq_client s, struct snd_seq_client_port sp,
	130	struct snd_seq_client d, struct snd_seq_client_port dp,
	131	struct snd_seq_port_subscribe *info);
1da177e4 LT	132
1da177e4 LT	133	/* subscribe port */
c7e0b5bf TI	134	int snd_seq_port_subscribe(struct snd_seq_client_port *port,
c7e0b5bf TI	135	struct snd_seq_port_subscribe *info);
1da177e4 LT	136
1da177e4 LT	137	/* get matched subscriber */
2eabc5ec TI	138	int snd_seq_port_get_subscription(struct snd_seq_port_subs_info *src_grp,
	139	struct snd_seq_addr *dest_addr,
	140	struct snd_seq_port_subscribe *subs);
1da177e4 LT	141
1da177e4 LT	142	#endif