mixer.c revision 79044 
1/*
2 * Copyright (c) 1999 Cameron Grant <gandalf@vilnya.demon.co.uk>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 * $FreeBSD: head/sys/dev/sound/pcm/mixer.c 79044 2001-07-01 18:53:24Z cg $
27 */
28
29#include <dev/sound/pcm/sound.h>
30
31#include "mixer_if.h"
32
33MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
34
35#define MIXER_NAMELEN	16
36struct snd_mixer {
37	KOBJ_FIELDS;
38	const char *type;
39	void *devinfo;
40	int busy;
41	int hwvol_muted;
42	int hwvol_mixer;
43	int hwvol_step;
44	u_int32_t hwvol_mute_level;
45	u_int32_t devs;
46	u_int32_t recdevs;
47	u_int32_t recsrc;
48	u_int16_t level[32];
49	char name[MIXER_NAMELEN];
50	void *lock;
51};
52
53static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = {
54	[SOUND_MIXER_VOLUME]	= 75,
55	[SOUND_MIXER_BASS]	= 50,
56	[SOUND_MIXER_TREBLE]	= 50,
57	[SOUND_MIXER_SYNTH]	= 75,
58	[SOUND_MIXER_PCM]	= 75,
59	[SOUND_MIXER_SPEAKER]	= 75,
60	[SOUND_MIXER_LINE]	= 75,
61	[SOUND_MIXER_MIC] 	= 0,
62	[SOUND_MIXER_CD]	= 75,
63	[SOUND_MIXER_LINE1]	= 75,
64	[SOUND_MIXER_VIDEO]	= 75,
65	[SOUND_MIXER_RECLEV]	= 0,
66	[SOUND_MIXER_OGAIN]	= 50,
67	[SOUND_MIXER_MONITOR]	= 75,
68};
69
70static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
71
72static d_open_t mixer_open;
73static d_close_t mixer_close;
74
75static struct cdevsw mixer_cdevsw = {
76	/* open */	mixer_open,
77	/* close */	mixer_close,
78	/* read */	noread,
79	/* write */	nowrite,
80	/* ioctl */	mixer_ioctl,
81	/* poll */	nopoll,
82	/* mmap */	nommap,
83	/* strategy */	nostrategy,
84	/* name */	"mixer",
85	/* maj */	SND_CDEV_MAJOR,
86	/* dump */	nodump,
87	/* psize */	nopsize,
88	/* flags */	0,
89};
90
91#ifdef USING_DEVFS
92static eventhandler_tag mixer_ehtag;
93#endif
94
95static dev_t
96mixer_get_devt(device_t dev)
97{
98	dev_t pdev;
99	int unit;
100
101	unit = device_get_unit(dev);
102	pdev = makedev(SND_CDEV_MAJOR, PCMMKMINOR(unit, SND_DEV_CTL, 0));
103
104	return pdev;
105}
106
107#ifdef SND_DYNSYSCTL
108static int
109mixer_lookup(char *devname)
110{
111	int i;
112
113	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
114		if (strncmp(devname, snd_mixernames[i],
115		    strlen(snd_mixernames[i])) == 0)
116			return i;
117	return -1;
118}
119#endif
120
121static int
122mixer_set(struct snd_mixer *mixer, unsigned dev, unsigned lev)
123{
124	unsigned l, r;
125	int v;
126
127	if ((dev >= SOUND_MIXER_NRDEVICES) || (0 == (mixer->devs & (1 << dev))))
128		return -1;
129
130	l = min((lev & 0x00ff), 100);
131	r = min(((lev & 0xff00) >> 8), 100);
132
133	v = MIXER_SET(mixer, dev, l, r);
134	if (v < 0)
135		return -1;
136
137	mixer->level[dev] = l | (r << 8);
138	return 0;
139}
140
141static int
142mixer_get(struct snd_mixer *mixer, int dev)
143{
144	if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev)))
145		return mixer->level[dev];
146	else return -1;
147}
148
149static int
150mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
151{
152	src &= mixer->recdevs;
153	if (src == 0)
154		src = SOUND_MASK_MIC;
155	mixer->recsrc = MIXER_SETRECSRC(mixer, src);
156	return 0;
157}
158
159static int
160mixer_getrecsrc(struct snd_mixer *mixer)
161{
162	return mixer->recsrc;
163}
164
165void
166mix_setdevs(struct snd_mixer *m, u_int32_t v)
167{
168	m->devs = v;
169}
170
171void
172mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
173{
174	m->recdevs = v;
175}
176
177u_int32_t
178mix_getdevs(struct snd_mixer *m)
179{
180	return m->devs;
181}
182
183u_int32_t
184mix_getrecdevs(struct snd_mixer *m)
185{
186	return m->recdevs;
187}
188
189void *
190mix_getdevinfo(struct snd_mixer *m)
191{
192	return m->devinfo;
193}
194
195int
196mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
197{
198	struct snd_mixer *m;
199	u_int16_t v;
200	dev_t pdev;
201	int i, unit;
202
203	m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
204	snprintf(m->name, MIXER_NAMELEN, "%s:mixer", device_get_nameunit(dev));
205	m->lock = snd_mtxcreate(m->name);
206	m->type = cls->name;
207	m->devinfo = devinfo;
208	m->busy = 0;
209
210	if (MIXER_INIT(m))
211		goto bad;
212
213	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
214		v = snd_mixerdefaults[i];
215		mixer_set(m, i, v | (v << 8));
216	}
217
218	mixer_setrecsrc(m, SOUND_MASK_MIC);
219
220	unit = device_get_unit(dev);
221	pdev = make_dev(&mixer_cdevsw, PCMMKMINOR(unit, SND_DEV_CTL, 0),
222		 UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit);
223	pdev->si_drv1 = m;
224
225	return 0;
226
227bad:
228	snd_mtxlock(m->lock);
229	snd_mtxfree(m->lock);
230	kobj_delete((kobj_t)m, M_MIXER);
231	return -1;
232}
233
234int
235mixer_uninit(device_t dev)
236{
237	int i;
238	struct snd_mixer *m;
239	dev_t pdev;
240
241	pdev = mixer_get_devt(dev);
242	m = pdev->si_drv1;
243	snd_mtxlock(m->lock);
244
245	if (m->busy) {
246		snd_mtxunlock(m->lock);
247		return EBUSY;
248	}
249
250	pdev->si_drv1 = NULL;
251	destroy_dev(pdev);
252
253	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
254		mixer_set(m, i, 0);
255
256	mixer_setrecsrc(m, SOUND_MASK_MIC);
257
258	MIXER_UNINIT(m);
259
260	snd_mtxfree(m->lock);
261	kobj_delete((kobj_t)m, M_MIXER);
262
263	return 0;
264}
265
266int
267mixer_reinit(device_t dev)
268{
269	struct snd_mixer *m;
270	dev_t pdev;
271	int i;
272
273	pdev = mixer_get_devt(dev);
274	m = pdev->si_drv1;
275	snd_mtxlock(m->lock);
276
277	i = MIXER_REINIT(m);
278	if (i) {
279		snd_mtxunlock(m->lock);
280		return i;
281	}
282
283	for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
284		mixer_set(m, i, m->level[i]);
285
286	mixer_setrecsrc(m, m->recsrc);
287	snd_mtxunlock(m->lock);
288
289	return 0;
290}
291
292#ifdef SND_DYNSYSCTL
293static int
294sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
295{
296	char devname[32];
297	int error, dev;
298	struct snd_mixer *m;
299
300	m = oidp->oid_arg1;
301	snd_mtxlock(m->lock);
302	strncpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
303	error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
304	if (error == 0 && req->newptr != NULL) {
305		dev = mixer_lookup(devname);
306		if (dev == -1) {
307			snd_mtxunlock(m->lock);
308			return EINVAL;
309		}
310		else if (dev != m->hwvol_mixer) {
311			m->hwvol_mixer = dev;
312			m->hwvol_muted = 0;
313		}
314	}
315	snd_mtxunlock(m->lock);
316	return error;
317}
318#endif
319
320int
321mixer_hwvol_init(device_t dev)
322{
323	struct snddev_info *d;
324	struct snd_mixer *m;
325	dev_t pdev;
326
327	d = device_get_softc(dev);
328	pdev = mixer_get_devt(dev);
329	m = pdev->si_drv1;
330	snd_mtxlock(m->lock);
331
332	m->hwvol_mixer = SOUND_MIXER_VOLUME;
333	m->hwvol_step = 5;
334#ifdef SND_DYNSYSCTL
335	SYSCTL_ADD_INT(&d->sysctl_tree, SYSCTL_CHILDREN(d->sysctl_tree_top),
336            OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, "");
337	SYSCTL_ADD_PROC(&d->sysctl_tree, SYSCTL_CHILDREN(d->sysctl_tree_top),
338            OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0,
339	    sysctl_hw_snd_hwvol_mixer, "A", "")
340#endif
341	snd_mtxunlock(m->lock);
342	return 0;
343}
344
345void
346mixer_hwvol_mute(device_t dev)
347{
348	struct snd_mixer *m;
349	dev_t pdev;
350
351	pdev = mixer_get_devt(dev);
352	m = pdev->si_drv1;
353	snd_mtxlock(m->lock);
354	if (m->hwvol_muted) {
355		m->hwvol_muted = 0;
356		mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level);
357	} else {
358		m->hwvol_muted++;
359		m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer);
360		mixer_set(m, m->hwvol_mixer, 0);
361	}
362	snd_mtxunlock(m->lock);
363}
364
365void
366mixer_hwvol_step(device_t dev, int left_step, int right_step)
367{
368	struct snd_mixer *m;
369	int level, left, right;
370	dev_t pdev;
371
372	pdev = mixer_get_devt(dev);
373	m = pdev->si_drv1;
374	snd_mtxlock(m->lock);
375	if (m->hwvol_muted) {
376		m->hwvol_muted = 0;
377		level = m->hwvol_mute_level;
378	} else
379		level = mixer_get(m, m->hwvol_mixer);
380	if (level != -1) {
381		left = level & 0xff;
382		right = level >> 8;
383		left += left_step * m->hwvol_step;
384		if (left < 0)
385			left = 0;
386		right += right_step * m->hwvol_step;
387		if (right < 0)
388			right = 0;
389		mixer_set(m, m->hwvol_mixer, left | right << 8);
390	}
391	snd_mtxunlock(m->lock);
392}
393
394/* ----------------------------------------------------------------------- */
395
396static int
397mixer_open(dev_t i_dev, int flags, int mode, struct proc *p)
398{
399	struct snd_mixer *m;
400	intrmask_t s;
401
402	s = spltty();
403	m = i_dev->si_drv1;
404	if (m->busy) {
405		splx(s);
406		return EBUSY;
407	}
408	m->busy = 1;
409
410	splx(s);
411	return 0;
412}
413
414static int
415mixer_close(dev_t i_dev, int flags, int mode, struct proc *p)
416{
417	struct snd_mixer *m;
418	intrmask_t s;
419
420	s = spltty();
421	m = i_dev->si_drv1;
422	if (!m->busy) {
423		splx(s);
424		return EBADF;
425	}
426	m->busy = 0;
427
428	splx(s);
429	return 0;
430}
431
432int
433mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
434{
435	struct snd_mixer *m;
436	intrmask_t s;
437	int ret, *arg_i = (int *)arg;
438	int v = -1, j = cmd & 0xff;
439
440	m = i_dev->si_drv1;
441	if (!m->busy)
442		return EBADF;
443
444	s = spltty();
445	snd_mtxlock(m->lock);
446	if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) {
447		if (j == SOUND_MIXER_RECSRC)
448			ret = mixer_setrecsrc(m, *arg_i);
449		else
450			ret = mixer_set(m, j, *arg_i);
451		snd_mtxunlock(m->lock);
452		splx(s);
453		return (ret == 0)? 0 : ENXIO;
454	}
455
456    	if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) {
457		switch (j) {
458    		case SOUND_MIXER_DEVMASK:
459    		case SOUND_MIXER_CAPS:
460    		case SOUND_MIXER_STEREODEVS:
461			v = mix_getdevs(m);
462			break;
463
464    		case SOUND_MIXER_RECMASK:
465			v = mix_getrecdevs(m);
466			break;
467
468    		case SOUND_MIXER_RECSRC:
469			v = mixer_getrecsrc(m);
470			break;
471
472		default:
473			v = mixer_get(m, j);
474		}
475		*arg_i = v;
476		snd_mtxunlock(m->lock);
477		return (v != -1)? 0 : ENXIO;
478	}
479	snd_mtxunlock(m->lock);
480	splx(s);
481	return ENXIO;
482}
483
484#ifdef USING_DEVFS
485static void
486mixer_clone(void *arg, char *name, int namelen, dev_t *dev)
487{
488	dev_t pdev;
489
490	if (*dev != NODEV)
491		return;
492	if (strcmp(name, "mixer") == 0) {
493		pdev = makedev(SND_CDEV_MAJOR, PCMMKMINOR(snd_unit, SND_DEV_CTL, 0));
494		if (pdev->si_flags & SI_NAMED)
495			*dev = pdev;
496	}
497}
498
499static void
500mixer_sysinit(void *p)
501{
502	mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
503}
504
505static void
506mixer_sysuninit(void *p)
507{
508	if (mixer_ehtag != NULL)
509		EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
510}
511
512SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
513SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
514#endif
515
516
517