1 /*-
2 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
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
27 #include <dev/sound/pcm/sound.h>
28
29 #include "mixer_if.h"
30
31 SND_DECLARE_FILE("$FreeBSD: releng/6.0/sys/dev/sound/pcm/mixer.c 151714 2005-10-26 21:17:40Z ariff $");
32
33 MALLOC_DEFINE(M_MIXER, "mixer", "mixer");
34
35 #define MIXER_NAMELEN 16
36 struct 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 struct mtx *lock;
51 };
52
53 static 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
70 static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES;
71
72 static d_open_t mixer_open;
73 static d_close_t mixer_close;
74
75 static struct cdevsw mixer_cdevsw = {
76 .d_version = D_VERSION,
77 .d_flags = D_TRACKCLOSE | D_NEEDGIANT,
78 .d_open = mixer_open,
79 .d_close = mixer_close,
80 .d_ioctl = mixer_ioctl,
81 .d_name = "mixer",
82 };
83
84 #ifdef USING_DEVFS
85 static eventhandler_tag mixer_ehtag;
86 #endif
87
88 static struct cdev *
89 mixer_get_devt(device_t dev)
90 {
91 struct snddev_info *snddev;
92
93 snddev = device_get_softc(dev);
94
95 return snddev->mixer_dev;
96 }
97
98 #ifdef SND_DYNSYSCTL
99 static int
100 mixer_lookup(char *devname)
101 {
102 int i;
103
104 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
105 if (strncmp(devname, snd_mixernames[i],
106 strlen(snd_mixernames[i])) == 0)
107 return i;
108 return -1;
109 }
110 #endif
111
112 static int
113 mixer_set(struct snd_mixer *mixer, unsigned dev, unsigned lev)
114 {
115 unsigned l, r;
116 int v;
117
118 if ((dev >= SOUND_MIXER_NRDEVICES) || (0 == (mixer->devs & (1 << dev))))
119 return -1;
120
121 l = min((lev & 0x00ff), 100);
122 r = min(((lev & 0xff00) >> 8), 100);
123
124 v = MIXER_SET(mixer, dev, l, r);
125 if (v < 0)
126 return -1;
127
128 mixer->level[dev] = l | (r << 8);
129 return 0;
130 }
131
132 static int
133 mixer_get(struct snd_mixer *mixer, int dev)
134 {
135 if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev)))
136 return mixer->level[dev];
137 else return -1;
138 }
139
140 static int
141 mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src)
142 {
143 src &= mixer->recdevs;
144 if (src == 0)
145 src = SOUND_MASK_MIC;
146 mixer->recsrc = MIXER_SETRECSRC(mixer, src);
147 return 0;
148 }
149
150 static int
151 mixer_getrecsrc(struct snd_mixer *mixer)
152 {
153 return mixer->recsrc;
154 }
155
156 void
157 mix_setdevs(struct snd_mixer *m, u_int32_t v)
158 {
159 m->devs = v;
160 }
161
162 void
163 mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
164 {
165 m->recdevs = v;
166 }
167
168 u_int32_t
169 mix_getdevs(struct snd_mixer *m)
170 {
171 return m->devs;
172 }
173
174 u_int32_t
175 mix_getrecdevs(struct snd_mixer *m)
176 {
177 return m->recdevs;
178 }
179
180 void *
181 mix_getdevinfo(struct snd_mixer *m)
182 {
183 return m->devinfo;
184 }
185
186 int
187 mixer_init(device_t dev, kobj_class_t cls, void *devinfo)
188 {
189 struct snddev_info *snddev;
190 struct snd_mixer *m;
191 u_int16_t v;
192 struct cdev *pdev;
193 int i, unit, val;
194
195 m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO);
196 snprintf(m->name, MIXER_NAMELEN, "%s:mixer", device_get_nameunit(dev));
197 m->lock = snd_mtxcreate(m->name, "pcm mixer");
198 m->type = cls->name;
199 m->devinfo = devinfo;
200 m->busy = 0;
201
202 if (MIXER_INIT(m))
203 goto bad;
204
205 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
206 v = snd_mixerdefaults[i];
207
208 if (resource_int_value(device_get_name(dev),
209 device_get_unit(dev), snd_mixernames[i], &val) == 0) {
210 if (val >= 0 && val <= 100) {
211 v = (u_int16_t) val;
212 }
213 }
214
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 snddev = device_get_softc(dev);
225 snddev->mixer_dev = pdev;
226
227 return 0;
228
229 bad:
230 snd_mtxlock(m->lock);
231 snd_mtxfree(m->lock);
232 kobj_delete((kobj_t)m, M_MIXER);
233 return -1;
234 }
235
236 int
237 mixer_uninit(device_t dev)
238 {
239 int i;
240 struct snd_mixer *m;
241 struct cdev *pdev;
242
243 pdev = mixer_get_devt(dev);
244 m = pdev->si_drv1;
245 snd_mtxlock(m->lock);
246
247 if (m->busy) {
248 snd_mtxunlock(m->lock);
249 return EBUSY;
250 }
251
252 pdev->si_drv1 = NULL;
253 destroy_dev(pdev);
254
255 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
256 mixer_set(m, i, 0);
257
258 mixer_setrecsrc(m, SOUND_MASK_MIC);
259
260 MIXER_UNINIT(m);
261
262 snd_mtxfree(m->lock);
263 kobj_delete((kobj_t)m, M_MIXER);
264
265 return 0;
266 }
267
268 int
269 mixer_reinit(device_t dev)
270 {
271 struct snd_mixer *m;
272 struct cdev *pdev;
273 int i;
274
275 pdev = mixer_get_devt(dev);
276 m = pdev->si_drv1;
277 snd_mtxlock(m->lock);
278
279 i = MIXER_REINIT(m);
280 if (i) {
281 snd_mtxunlock(m->lock);
282 return i;
283 }
284
285 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
286 mixer_set(m, i, m->level[i]);
287
288 mixer_setrecsrc(m, m->recsrc);
289 snd_mtxunlock(m->lock);
290
291 return 0;
292 }
293
294 #ifdef SND_DYNSYSCTL
295 static int
296 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS)
297 {
298 char devname[32];
299 int error, dev;
300 struct snd_mixer *m;
301
302 m = oidp->oid_arg1;
303 snd_mtxlock(m->lock);
304 strncpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname));
305 snd_mtxunlock(m->lock);
306 error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req);
307 snd_mtxlock(m->lock);
308 if (error == 0 && req->newptr != NULL) {
309 dev = mixer_lookup(devname);
310 if (dev == -1) {
311 snd_mtxunlock(m->lock);
312 return EINVAL;
313 }
314 else if (dev != m->hwvol_mixer) {
315 m->hwvol_mixer = dev;
316 m->hwvol_muted = 0;
317 }
318 }
319 snd_mtxunlock(m->lock);
320 return error;
321 }
322 #endif
323
324 int
325 mixer_hwvol_init(device_t dev)
326 {
327 struct snd_mixer *m;
328 struct cdev *pdev;
329
330 pdev = mixer_get_devt(dev);
331 m = pdev->si_drv1;
332
333 m->hwvol_mixer = SOUND_MIXER_VOLUME;
334 m->hwvol_step = 5;
335 #ifdef SND_DYNSYSCTL
336 SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
337 OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, "");
338 SYSCTL_ADD_PROC(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
339 OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0,
340 sysctl_hw_snd_hwvol_mixer, "A", "");
341 #endif
342 return 0;
343 }
344
345 void
346 mixer_hwvol_mute(device_t dev)
347 {
348 struct snd_mixer *m;
349 struct cdev *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
365 void
366 mixer_hwvol_step(device_t dev, int left_step, int right_step)
367 {
368 struct snd_mixer *m;
369 int level, left, right;
370 struct cdev *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
396 static int
397 mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td)
398 {
399 struct snd_mixer *m;
400 intrmask_t s;
401
402 m = i_dev->si_drv1;
403 s = spltty();
404 snd_mtxlock(m->lock);
405
406 m->busy++;
407
408 snd_mtxunlock(m->lock);
409 splx(s);
410 return 0;
411 }
412
413 static int
414 mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td)
415 {
416 struct snd_mixer *m;
417 intrmask_t s;
418
419 m = i_dev->si_drv1;
420 s = spltty();
421 snd_mtxlock(m->lock);
422
423 if (!m->busy) {
424 snd_mtxunlock(m->lock);
425 splx(s);
426 return EBADF;
427 }
428 m->busy--;
429
430 snd_mtxunlock(m->lock);
431 splx(s);
432 return 0;
433 }
434
435 int
436 mixer_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, struct thread *td)
437 {
438 struct snd_mixer *m;
439 intrmask_t s;
440 int ret, *arg_i = (int *)arg;
441 int v = -1, j = cmd & 0xff;
442
443 m = i_dev->si_drv1;
444 if (!m->busy)
445 return EBADF;
446
447 s = spltty();
448 snd_mtxlock(m->lock);
449 if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) {
450 if (j == SOUND_MIXER_RECSRC)
451 ret = mixer_setrecsrc(m, *arg_i);
452 else
453 ret = mixer_set(m, j, *arg_i);
454 snd_mtxunlock(m->lock);
455 splx(s);
456 return (ret == 0)? 0 : ENXIO;
457 }
458
459 if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) {
460 switch (j) {
461 case SOUND_MIXER_DEVMASK:
462 case SOUND_MIXER_CAPS:
463 case SOUND_MIXER_STEREODEVS:
464 v = mix_getdevs(m);
465 break;
466
467 case SOUND_MIXER_RECMASK:
468 v = mix_getrecdevs(m);
469 break;
470
471 case SOUND_MIXER_RECSRC:
472 v = mixer_getrecsrc(m);
473 break;
474
475 default:
476 v = mixer_get(m, j);
477 }
478 *arg_i = v;
479 snd_mtxunlock(m->lock);
480 return (v != -1)? 0 : ENXIO;
481 }
482 snd_mtxunlock(m->lock);
483 splx(s);
484 return ENXIO;
485 }
486
487 #ifdef USING_DEVFS
488 static void
489 mixer_clone(void *arg, struct ucred *cred, char *name, int namelen,
490 struct cdev **dev)
491 {
492 struct snddev_info *sd;
493
494 if (*dev != NULL)
495 return;
496 if (strcmp(name, "mixer") == 0) {
497 sd = devclass_get_softc(pcm_devclass, snd_unit);
498 if (sd != NULL) {
499 *dev = sd->mixer_dev;
500 dev_ref(*dev);
501 }
502 }
503 }
504
505 static void
506 mixer_sysinit(void *p)
507 {
508 mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
509 }
510
511 static void
512 mixer_sysuninit(void *p)
513 {
514 if (mixer_ehtag != NULL)
515 EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
516 }
517
518 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
519 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
520 #endif
521
522
Cache object: 5fb76cf894bad2d236ef48ca492c146d
|