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

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

#include <sound/driver.h>

#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/slab.h>
#include <linux/time.h>
#include <sound/core.h>
#include <sound/minors.h>
#include <sound/info.h>
#include <linux/sound.h>

#define SNDRV_OSS_MINORS 128

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

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;
	down(&sound_oss_mutex);
	mreg = snd_oss_minors[minor];
	if (mreg && mreg->type == type)
		private_data = mreg->private_data;
	else
		private_data = NULL;
	up(&sound_oss_mutex);
	return private_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:
		snd_assert(card != NULL && 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:
		snd_assert(card != NULL && 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:
		snd_assert(card != NULL && 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;
	}
	snd_assert(minor >= 0 && minor < SNDRV_OSS_MINORS, return -EINVAL);
	return minor;
}

int snd_register_oss_device(int type, struct snd_card *card, int dev,
			    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 = NULL;

	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;
	down(&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;
	}
	if (card)
		carddev = card->dev;
	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;
	}
	up(&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;
	up(&sound_oss_mutex);
	kfree(preg);
      	return -EBUSY;
}

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 (minor < 0)
		return minor;
	down(&sound_oss_mutex);
	mptr = snd_oss_minors[minor];
	if (mptr == NULL) {
		up(&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;
	up(&sound_oss_mutex);
	kfree(mptr);
	return 0;
}

/*
 *  INFO PART
 */

#ifdef CONFIG_PROC_FS

static struct snd_info_entry *snd_minor_info_oss_entry = NULL;

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;

	down(&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));
	}
	up(&sound_oss_mutex);
}

#endif /* CONFIG_PROC_FS */

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

	entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root);
	if (entry) {
		entry->c.text.read_size = PAGE_SIZE;
		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;
#endif
	return 0;
}

int __exit snd_minor_info_oss_done(void)
{
#ifdef CONFIG_PROC_FS
	if (snd_minor_info_oss_entry)
		snd_info_unregister(snd_minor_info_oss_entry);
#endif
	return 0;
}

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