[GitHub/mt8127/android_kernel_alcatel_ttab.git] / sound / core / sound_oss.c

/*
 *  Advanced Linux Sound Architecture
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *
 *
 *   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
 *
 */

#ifdef CONFIG_SND_OSSEMUL

#if !defined(CONFIG_SOUND) && !(defined(MODULE) && defined(CONFIG_SOUND_MODULE))
#error "Enable the OSS soundcore multiplexer (CONFIG_SOUND) in the kernel."
#endif

#include <linux/init.h>
#include <linux/export.h>
#include <linux/slab.h>
#include <linux/time.h>
#include <sound/core.h>
#include <sound/minors.h>
#include <sound/info.h>
#include <linux/sound.h>
#include <linux/mutex.h>

#define SNDRV_OSS_MINORS 256

static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS];
static DEFINE_MUTEX(sound_oss_mutex);

/* NOTE: This function increments the refcount of the associated card like
 * snd_lookup_minor_data(); the caller must call snd_card_unref() appropriately
 */
void *snd_lookup_oss_minor_data(unsigned int minor, int type)
{
	struct snd_minor *mreg;
	void *private_data;

	if (minor >= ARRAY_SIZE(snd_oss_minors))
		return NULL;
	mutex_lock(&sound_oss_mutex);
	mreg = snd_oss_minors[minor];
	if (mreg && mreg->type == type) {
		private_data = mreg->private_data;
		if (private_data && mreg->card_ptr)
			atomic_inc(&mreg->card_ptr->refcount);
	} else
		private_data = NULL;
	mutex_unlock(&sound_oss_mutex);
	return private_data;
}

EXPORT_SYMBOL(snd_lookup_oss_minor_data);

static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
{
	int minor;

	switch (type) {
	case SNDRV_OSS_DEVICE_TYPE_MIXER:
		if (snd_BUG_ON(!card || dev < 0 || dev > 1))
			return -EINVAL;
		minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIXER1 : SNDRV_MINOR_OSS_MIXER));
		break;
	case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
		minor = SNDRV_MINOR_OSS_SEQUENCER;
		break;
	case SNDRV_OSS_DEVICE_TYPE_MUSIC:
		minor = SNDRV_MINOR_OSS_MUSIC;
		break;
	case SNDRV_OSS_DEVICE_TYPE_PCM:
		if (snd_BUG_ON(!card || dev < 0 || dev > 1))
			return -EINVAL;
		minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_PCM1 : SNDRV_MINOR_OSS_PCM));
		break;
	case SNDRV_OSS_DEVICE_TYPE_MIDI:
		if (snd_BUG_ON(!card || dev < 0 || dev > 1))
			return -EINVAL;
		minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIDI1 : SNDRV_MINOR_OSS_MIDI));
		break;
	case SNDRV_OSS_DEVICE_TYPE_DMFM:
		minor = SNDRV_MINOR_OSS(card->number, SNDRV_MINOR_OSS_DMFM);
		break;
	case SNDRV_OSS_DEVICE_TYPE_SNDSTAT:
		minor = SNDRV_MINOR_OSS_SNDSTAT;
		break;
	default:
		return -EINVAL;
	}
	if (minor < 0 || minor >= SNDRV_OSS_MINORS)
		return -EINVAL;
	return minor;
}

int snd_register_oss_device(int type, struct snd_card *card, int dev,
			    const struct file_operations *f_ops, void *private_data,
			    const char *name)
{
	int minor = snd_oss_kernel_minor(type, card, dev);
	int minor_unit;
	struct snd_minor *preg;
	int cidx = SNDRV_MINOR_OSS_CARD(minor);
	int track2 = -1;
	int register1 = -1, register2 = -1;
	struct device *carddev = snd_card_get_device_link(card);

	if (card && card->number >= SNDRV_MINOR_OSS_DEVICES)
		return 0; /* ignore silently */
	if (minor < 0)
		return minor;
	preg = kmalloc(sizeof(struct snd_minor), GFP_KERNEL);
	if (preg == NULL)
		return -ENOMEM;
	preg->type = type;
	preg->card = card ? card->number : -1;
	preg->device = dev;
	preg->f_ops = f_ops;
	preg->private_data = private_data;
	preg->card_ptr = card;
	mutex_lock(&sound_oss_mutex);
	snd_oss_minors[minor] = preg;
	minor_unit = SNDRV_MINOR_OSS_DEVICE(minor);
	switch (minor_unit) {
	case SNDRV_MINOR_OSS_PCM:
		track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_AUDIO);
		break;
	case SNDRV_MINOR_OSS_MIDI:
		track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI);
		break;
	case SNDRV_MINOR_OSS_MIDI1:
		track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1);
		break;
	}
	register1 = register_sound_special_device(f_ops, minor, carddev);
	if (register1 != minor)
		goto __end;
	if (track2 >= 0) {
		register2 = register_sound_special_device(f_ops, track2,
							  carddev);
		if (register2 != track2)
			goto __end;
		snd_oss_minors[track2] = preg;
	}
	mutex_unlock(&sound_oss_mutex);
	return 0;

      __end:
      	if (register2 >= 0)
      		unregister_sound_special(register2);
      	if (register1 >= 0)
      		unregister_sound_special(register1);
	snd_oss_minors[minor] = NULL;
	mutex_unlock(&sound_oss_mutex);
	kfree(preg);
      	return -EBUSY;
}

EXPORT_SYMBOL(snd_register_oss_device);

int snd_unregister_oss_device(int type, struct snd_card *card, int dev)
{
	int minor = snd_oss_kernel_minor(type, card, dev);
	int cidx = SNDRV_MINOR_OSS_CARD(minor);
	int track2 = -1;
	struct snd_minor *mptr;

	if (card && card->number >= SNDRV_MINOR_OSS_DEVICES)
		return 0;
	if (minor < 0)
		return minor;
	mutex_lock(&sound_oss_mutex);
	mptr = snd_oss_minors[minor];
	if (mptr == NULL) {
		mutex_unlock(&sound_oss_mutex);
		return -ENOENT;
	}
	unregister_sound_special(minor);
	switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
	case SNDRV_MINOR_OSS_PCM:
		track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_AUDIO);
		break;
	case SNDRV_MINOR_OSS_MIDI:
		track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI);
		break;
	case SNDRV_MINOR_OSS_MIDI1:
		track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1);
		break;
	}
	if (track2 >= 0) {
		unregister_sound_special(track2);
		snd_oss_minors[track2] = NULL;
	}
	snd_oss_minors[minor] = NULL;
	mutex_unlock(&sound_oss_mutex);
	kfree(mptr);
	return 0;
}

EXPORT_SYMBOL(snd_unregister_oss_device);

/*
 *  INFO PART
 */

#ifdef CONFIG_PROC_FS

static struct snd_info_entry *snd_minor_info_oss_entry;

static const char *snd_oss_device_type_name(int type)
{
	switch (type) {
	case SNDRV_OSS_DEVICE_TYPE_MIXER:
		return "mixer";
	case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
	case SNDRV_OSS_DEVICE_TYPE_MUSIC:
		return "sequencer";
	case SNDRV_OSS_DEVICE_TYPE_PCM:
		return "digital audio";
	case SNDRV_OSS_DEVICE_TYPE_MIDI:
		return "raw midi";
	case SNDRV_OSS_DEVICE_TYPE_DMFM:
		return "hardware dependent";
	default:
		return "?";
	}
}

static void snd_minor_info_oss_read(struct snd_info_entry *entry,
				    struct snd_info_buffer *buffer)
{
	int minor;
	struct snd_minor *mptr;

	mutex_lock(&sound_oss_mutex);
	for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) {
		if (!(mptr = snd_oss_minors[minor]))
			continue;
		if (mptr->card >= 0)
			snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", minor,
				    mptr->card, mptr->device,
				    snd_oss_device_type_name(mptr->type));
		else
			snd_iprintf(buffer, "%3i:       : %s\n", minor,
				    snd_oss_device_type_name(mptr->type));
	}
	mutex_unlock(&sound_oss_mutex);
}


int __init snd_minor_info_oss_init(void)
{
	struct snd_info_entry *entry;

	entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root);
	if (entry) {
		entry->c.text.read = snd_minor_info_oss_read;
		if (snd_info_register(entry) < 0) {
			snd_info_free_entry(entry);
			entry = NULL;
		}
	}
	snd_minor_info_oss_entry = entry;
	return 0;
}

int __exit snd_minor_info_oss_done(void)
{
	snd_info_free_entry(snd_minor_info_oss_entry);
	return 0;
}
#endif /* CONFIG_PROC_FS */

#endif /* CONFIG_SND_OSSEMUL */
Commit	Line	Data
1da177e4 LT	1	/*
1da177e4 LT	2	* Advanced Linux Sound Architecture
c1017a4c	3	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
1da177e4 LT	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
1da177e4 LT	22	#ifdef CONFIG_SND_OSSEMUL
	23
	24	#if !defined(CONFIG_SOUND) && !(defined(MODULE) && defined(CONFIG_SOUND_MODULE))
	25	#error "Enable the OSS soundcore multiplexer (CONFIG_SOUND) in the kernel."
	26	#endif
	27
	28	#include <linux/init.h>
d81a6d71	29	#include <linux/export.h>
1da177e4 LT	30	#include <linux/slab.h>
	31	#include <linux/time.h>
	32	#include <sound/core.h>
	33	#include <sound/minors.h>
	34	#include <sound/info.h>
	35	#include <linux/sound.h>
1a60d4c5	36	#include <linux/mutex.h>
1da177e4	37
779ae5a0	38	#define SNDRV_OSS_MINORS 256
1da177e4	39
6983b724	40	static struct snd_minor *snd_oss_minors[SNDRV_OSS_MINORS];
1a60d4c5	41	static DEFINE_MUTEX(sound_oss_mutex);
1da177e4	42
a0830dbd TI	43	/* NOTE: This function increments the refcount of the associated card like
	44	* snd_lookup_minor_data(); the caller must call snd_card_unref() appropriately
	45	*/
f87135f5 CL	46	void *snd_lookup_oss_minor_data(unsigned int minor, int type)
	47	{
	48	struct snd_minor *mreg;
	49	void *private_data;
	50
3a63e444	51	if (minor >= ARRAY_SIZE(snd_oss_minors))
f87135f5	52	return NULL;
1a60d4c5	53	mutex_lock(&sound_oss_mutex);
f87135f5	54	mreg = snd_oss_minors[minor];
a0830dbd	55	if (mreg && mreg->type == type) {
f87135f5	56	private_data = mreg->private_data;
8bb4d9ce	57	if (private_data && mreg->card_ptr)
a0830dbd TI	58	atomic_inc(&mreg->card_ptr->refcount);
a0830dbd TI	59	} else
f87135f5	60	private_data = NULL;
1a60d4c5	61	mutex_unlock(&sound_oss_mutex);
f87135f5 CL	62	return private_data;
	63	}
	64
c0d3fb39 TI	65	EXPORT_SYMBOL(snd_lookup_oss_minor_data);
c0d3fb39 TI	66
174c1f65	67	static int snd_oss_kernel_minor(int type, struct snd_card *card, int dev)
1da177e4 LT	68	{
	69	int minor;
	70
	71	switch (type) {
	72	case SNDRV_OSS_DEVICE_TYPE_MIXER:
7eaa943c TI	73	if (snd_BUG_ON(!card \|\| dev < 0 \|\| dev > 1))
7eaa943c TI	74	return -EINVAL;
1da177e4 LT	75	minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIXER1 : SNDRV_MINOR_OSS_MIXER));
	76	break;
	77	case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
	78	minor = SNDRV_MINOR_OSS_SEQUENCER;
	79	break;
	80	case SNDRV_OSS_DEVICE_TYPE_MUSIC:
	81	minor = SNDRV_MINOR_OSS_MUSIC;
	82	break;
	83	case SNDRV_OSS_DEVICE_TYPE_PCM:
7eaa943c TI	84	if (snd_BUG_ON(!card \|\| dev < 0 \|\| dev > 1))
7eaa943c TI	85	return -EINVAL;
1da177e4 LT	86	minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_PCM1 : SNDRV_MINOR_OSS_PCM));
	87	break;
	88	case SNDRV_OSS_DEVICE_TYPE_MIDI:
7eaa943c TI	89	if (snd_BUG_ON(!card \|\| dev < 0 \|\| dev > 1))
7eaa943c TI	90	return -EINVAL;
1da177e4 LT	91	minor = SNDRV_MINOR_OSS(card->number, (dev ? SNDRV_MINOR_OSS_MIDI1 : SNDRV_MINOR_OSS_MIDI));
	92	break;
	93	case SNDRV_OSS_DEVICE_TYPE_DMFM:
	94	minor = SNDRV_MINOR_OSS(card->number, SNDRV_MINOR_OSS_DMFM);
	95	break;
	96	case SNDRV_OSS_DEVICE_TYPE_SNDSTAT:
	97	minor = SNDRV_MINOR_OSS_SNDSTAT;
	98	break;
	99	default:
	100	return -EINVAL;
	101	}
808c569f	102	if (minor < 0 \|\| minor >= SNDRV_OSS_MINORS)
7eaa943c	103	return -EINVAL;
1da177e4 LT	104	return minor;
	105	}
	106
174c1f65	107	int snd_register_oss_device(int type, struct snd_card *card, int dev,
99ac48f5	108	const struct file_operations f_ops, void private_data,
f87135f5	109	const char *name)
1da177e4 LT	110	{
	111	int minor = snd_oss_kernel_minor(type, card, dev);
	112	int minor_unit;
174c1f65	113	struct snd_minor *preg;
1da177e4 LT	114	int cidx = SNDRV_MINOR_OSS_CARD(minor);
	115	int track2 = -1;
	116	int register1 = -1, register2 = -1;
7d2aae1e	117	struct device *carddev = snd_card_get_device_link(card);
1da177e4	118
779ae5a0	119	if (card && card->number >= SNDRV_MINOR_OSS_DEVICES)
d001544d	120	return 0; /* ignore silently */
1da177e4 LT	121	if (minor < 0)
1da177e4 LT	122	return minor;
6983b724	123	preg = kmalloc(sizeof(struct snd_minor), GFP_KERNEL);
1da177e4 LT	124	if (preg == NULL)
1da177e4 LT	125	return -ENOMEM;
2af677fc	126	preg->type = type;
6983b724	127	preg->card = card ? card->number : -1;
1da177e4	128	preg->device = dev;
2af677fc	129	preg->f_ops = f_ops;
f87135f5	130	preg->private_data = private_data;
a0830dbd	131	preg->card_ptr = card;
1a60d4c5	132	mutex_lock(&sound_oss_mutex);
6983b724	133	snd_oss_minors[minor] = preg;
1da177e4 LT	134	minor_unit = SNDRV_MINOR_OSS_DEVICE(minor);
	135	switch (minor_unit) {
	136	case SNDRV_MINOR_OSS_PCM:
	137	track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_AUDIO);
	138	break;
	139	case SNDRV_MINOR_OSS_MIDI:
	140	track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI);
	141	break;
	142	case SNDRV_MINOR_OSS_MIDI1:
	143	track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1);
	144	break;
	145	}
2af677fc	146	register1 = register_sound_special_device(f_ops, minor, carddev);
1da177e4 LT	147	if (register1 != minor)
	148	goto __end;
	149	if (track2 >= 0) {
2af677fc CL	150	register2 = register_sound_special_device(f_ops, track2,
2af677fc CL	151	carddev);
1da177e4 LT	152	if (register2 != track2)
1da177e4 LT	153	goto __end;
f87135f5	154	snd_oss_minors[track2] = preg;
1da177e4	155	}
1a60d4c5	156	mutex_unlock(&sound_oss_mutex);
1da177e4 LT	157	return 0;
	158
	159	__end:
	160	if (register2 >= 0)
	161	unregister_sound_special(register2);
	162	if (register1 >= 0)
	163	unregister_sound_special(register1);
6983b724	164	snd_oss_minors[minor] = NULL;
1a60d4c5	165	mutex_unlock(&sound_oss_mutex);
1da177e4 LT	166	kfree(preg);
	167	return -EBUSY;
	168	}
	169
c0d3fb39 TI	170	EXPORT_SYMBOL(snd_register_oss_device);
c0d3fb39 TI	171
174c1f65	172	int snd_unregister_oss_device(int type, struct snd_card *card, int dev)
1da177e4 LT	173	{
	174	int minor = snd_oss_kernel_minor(type, card, dev);
	175	int cidx = SNDRV_MINOR_OSS_CARD(minor);
	176	int track2 = -1;
174c1f65	177	struct snd_minor *mptr;
1da177e4	178
779ae5a0	179	if (card && card->number >= SNDRV_MINOR_OSS_DEVICES)
d001544d	180	return 0;
1da177e4 LT	181	if (minor < 0)
1da177e4 LT	182	return minor;
1a60d4c5	183	mutex_lock(&sound_oss_mutex);
6983b724	184	mptr = snd_oss_minors[minor];
1da177e4	185	if (mptr == NULL) {
1a60d4c5	186	mutex_unlock(&sound_oss_mutex);
1da177e4 LT	187	return -ENOENT;
	188	}
	189	unregister_sound_special(minor);
	190	switch (SNDRV_MINOR_OSS_DEVICE(minor)) {
	191	case SNDRV_MINOR_OSS_PCM:
	192	track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_AUDIO);
	193	break;
	194	case SNDRV_MINOR_OSS_MIDI:
	195	track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI);
	196	break;
	197	case SNDRV_MINOR_OSS_MIDI1:
	198	track2 = SNDRV_MINOR_OSS(cidx, SNDRV_MINOR_OSS_DMMIDI1);
	199	break;
	200	}
f87135f5	201	if (track2 >= 0) {
1da177e4	202	unregister_sound_special(track2);
f87135f5 CL	203	snd_oss_minors[track2] = NULL;
f87135f5 CL	204	}
6983b724	205	snd_oss_minors[minor] = NULL;
1a60d4c5	206	mutex_unlock(&sound_oss_mutex);
1da177e4 LT	207	kfree(mptr);
	208	return 0;
	209	}
	210
c0d3fb39 TI	211	EXPORT_SYMBOL(snd_unregister_oss_device);
c0d3fb39 TI	212
1da177e4 LT	213	/*
	214	* INFO PART
	215	*/
	216
	217	#ifdef CONFIG_PROC_FS
	218
6581f4e7	219	static struct snd_info_entry *snd_minor_info_oss_entry;
1da177e4	220
2af677fc CL	221	static const char *snd_oss_device_type_name(int type)
	222	{
	223	switch (type) {
	224	case SNDRV_OSS_DEVICE_TYPE_MIXER:
	225	return "mixer";
	226	case SNDRV_OSS_DEVICE_TYPE_SEQUENCER:
	227	case SNDRV_OSS_DEVICE_TYPE_MUSIC:
	228	return "sequencer";
	229	case SNDRV_OSS_DEVICE_TYPE_PCM:
	230	return "digital audio";
	231	case SNDRV_OSS_DEVICE_TYPE_MIDI:
	232	return "raw midi";
	233	case SNDRV_OSS_DEVICE_TYPE_DMFM:
	234	return "hardware dependent";
	235	default:
	236	return "?";
	237	}
	238	}
	239
174c1f65 TI	240	static void snd_minor_info_oss_read(struct snd_info_entry *entry,
174c1f65 TI	241	struct snd_info_buffer *buffer)
1da177e4	242	{
6983b724	243	int minor;
174c1f65	244	struct snd_minor *mptr;
1da177e4	245
1a60d4c5	246	mutex_lock(&sound_oss_mutex);
6983b724 CL	247	for (minor = 0; minor < SNDRV_OSS_MINORS; ++minor) {
	248	if (!(mptr = snd_oss_minors[minor]))
	249	continue;
	250	if (mptr->card >= 0)
	251	snd_iprintf(buffer, "%3i: [%i-%2i]: %s\n", minor,
	252	mptr->card, mptr->device,
	253	snd_oss_device_type_name(mptr->type));
	254	else
	255	snd_iprintf(buffer, "%3i: : %s\n", minor,
	256	snd_oss_device_type_name(mptr->type));
1da177e4	257	}
1a60d4c5	258	mutex_unlock(&sound_oss_mutex);
1da177e4 LT	259	}
1da177e4 LT	260
1da177e4 LT	261
	262	int __init snd_minor_info_oss_init(void)
	263	{
174c1f65	264	struct snd_info_entry *entry;
1da177e4 LT	265
	266	entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root);
	267	if (entry) {
1da177e4 LT	268	entry->c.text.read = snd_minor_info_oss_read;
	269	if (snd_info_register(entry) < 0) {
	270	snd_info_free_entry(entry);
	271	entry = NULL;
	272	}
	273	}
	274	snd_minor_info_oss_entry = entry;
1da177e4 LT	275	return 0;
	276	}
	277
	278	int __exit snd_minor_info_oss_done(void)
	279	{
746d4a02	280	snd_info_free_entry(snd_minor_info_oss_entry);
1da177e4 LT	281	return 0;
1da177e4 LT	282	}
e28563cc	283	#endif /* CONFIG_PROC_FS */
1da177e4	284
1da177e4	285	#endif /* CONFIG_SND_OSSEMUL */