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
27 #include <dev/sound/pcm/sound.h>
28
29 #include "mixer_if.h"
30
31 SND_DECLARE_FILE("$FreeBSD$");
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 void *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 /* 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
92 static eventhandler_tag mixer_ehtag;
93 #endif
94
95 static dev_t
96 mixer_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
108 static int
109 mixer_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
121 static int
122 mixer_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
141 static int
142 mixer_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
149 static int
150 mixer_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
159 static int
160 mixer_getrecsrc(struct snd_mixer *mixer)
161 {
162 return mixer->recsrc;
163 }
164
165 void
166 mix_setdevs(struct snd_mixer *m, u_int32_t v)
167 {
168 m->devs = v;
169 }
170
171 void
172 mix_setrecdevs(struct snd_mixer *m, u_int32_t v)
173 {
174 m->recdevs = v;
175 }
176
177 u_int32_t
178 mix_getdevs(struct snd_mixer *m)
179 {
180 return m->devs;
181 }
182
183 u_int32_t
184 mix_getrecdevs(struct snd_mixer *m)
185 {
186 return m->recdevs;
187 }
188
189 void *
190 mix_getdevinfo(struct snd_mixer *m)
191 {
192 return m->devinfo;
193 }
194
195 int
196 mixer_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, "pcm mixer");
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
227 bad:
228 snd_mtxlock(m->lock);
229 snd_mtxfree(m->lock);
230 kobj_delete((kobj_t)m, M_MIXER);
231 return -1;
232 }
233
234 int
235 mixer_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
266 int
267 mixer_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
293 static int
294 sysctl_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
320 int
321 mixer_hwvol_init(device_t dev)
322 {
323 struct snd_mixer *m;
324 dev_t pdev;
325
326 pdev = mixer_get_devt(dev);
327 m = pdev->si_drv1;
328 snd_mtxlock(m->lock);
329
330 m->hwvol_mixer = SOUND_MIXER_VOLUME;
331 m->hwvol_step = 5;
332 #ifdef SND_DYNSYSCTL
333 SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
334 OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, "");
335 SYSCTL_ADD_PROC(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
336 OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0,
337 sysctl_hw_snd_hwvol_mixer, "A", "")
338 #endif
339 snd_mtxunlock(m->lock);
340 return 0;
341 }
342
343 void
344 mixer_hwvol_mute(device_t dev)
345 {
346 struct snd_mixer *m;
347 dev_t pdev;
348
349 pdev = mixer_get_devt(dev);
350 m = pdev->si_drv1;
351 snd_mtxlock(m->lock);
352 if (m->hwvol_muted) {
353 m->hwvol_muted = 0;
354 mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level);
355 } else {
356 m->hwvol_muted++;
357 m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer);
358 mixer_set(m, m->hwvol_mixer, 0);
359 }
360 snd_mtxunlock(m->lock);
361 }
362
363 void
364 mixer_hwvol_step(device_t dev, int left_step, int right_step)
365 {
366 struct snd_mixer *m;
367 int level, left, right;
368 dev_t pdev;
369
370 pdev = mixer_get_devt(dev);
371 m = pdev->si_drv1;
372 snd_mtxlock(m->lock);
373 if (m->hwvol_muted) {
374 m->hwvol_muted = 0;
375 level = m->hwvol_mute_level;
376 } else
377 level = mixer_get(m, m->hwvol_mixer);
378 if (level != -1) {
379 left = level & 0xff;
380 right = level >> 8;
381 left += left_step * m->hwvol_step;
382 if (left < 0)
383 left = 0;
384 right += right_step * m->hwvol_step;
385 if (right < 0)
386 right = 0;
387 mixer_set(m, m->hwvol_mixer, left | right << 8);
388 }
389 snd_mtxunlock(m->lock);
390 }
391
392 /* ----------------------------------------------------------------------- */
393
394 static int
395 mixer_open(dev_t i_dev, int flags, int mode, struct proc *p)
396 {
397 struct snd_mixer *m;
398 intrmask_t s;
399
400 m = i_dev->si_drv1;
401 s = spltty();
402 snd_mtxlock(m->lock);
403
404 m->busy++;
405
406 snd_mtxunlock(m->lock);
407 splx(s);
408 return 0;
409 }
410
411 static int
412 mixer_close(dev_t i_dev, int flags, int mode, struct proc *p)
413 {
414 struct snd_mixer *m;
415 intrmask_t s;
416
417 m = i_dev->si_drv1;
418 s = spltty();
419 snd_mtxlock(m->lock);
420
421 if (!m->busy) {
422 snd_mtxunlock(m->lock);
423 splx(s);
424 return EBADF;
425 }
426 m->busy--;
427
428 snd_mtxunlock(m->lock);
429 splx(s);
430 return 0;
431 }
432
433 int
434 mixer_ioctl(dev_t i_dev, u_long cmd, caddr_t arg, int mode, struct proc *p)
435 {
436 struct snd_mixer *m;
437 intrmask_t s;
438 int ret, *arg_i = (int *)arg;
439 int v = -1, j = cmd & 0xff;
440
441 m = i_dev->si_drv1;
442 if (!m->busy)
443 return EBADF;
444
445 s = spltty();
446 snd_mtxlock(m->lock);
447 if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) {
448 if (j == SOUND_MIXER_RECSRC)
449 ret = mixer_setrecsrc(m, *arg_i);
450 else
451 ret = mixer_set(m, j, *arg_i);
452 snd_mtxunlock(m->lock);
453 splx(s);
454 return (ret == 0)? 0 : ENXIO;
455 }
456
457 if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) {
458 switch (j) {
459 case SOUND_MIXER_DEVMASK:
460 case SOUND_MIXER_CAPS:
461 case SOUND_MIXER_STEREODEVS:
462 v = mix_getdevs(m);
463 break;
464
465 case SOUND_MIXER_RECMASK:
466 v = mix_getrecdevs(m);
467 break;
468
469 case SOUND_MIXER_RECSRC:
470 v = mixer_getrecsrc(m);
471 break;
472
473 default:
474 v = mixer_get(m, j);
475 }
476 *arg_i = v;
477 snd_mtxunlock(m->lock);
478 return (v != -1)? 0 : ENXIO;
479 }
480 snd_mtxunlock(m->lock);
481 splx(s);
482 return ENXIO;
483 }
484
485 #ifdef USING_DEVFS
486 static void
487 mixer_clone(void *arg, char *name, int namelen, dev_t *dev)
488 {
489 dev_t pdev;
490
491 if (*dev != NODEV)
492 return;
493 if (strcmp(name, "mixer") == 0) {
494 pdev = makedev(SND_CDEV_MAJOR, PCMMKMINOR(snd_unit, SND_DEV_CTL, 0));
495 if (pdev->si_flags & SI_NAMED)
496 *dev = pdev;
497 }
498 }
499
500 static void
501 mixer_sysinit(void *p)
502 {
503 mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000);
504 }
505
506 static void
507 mixer_sysuninit(void *p)
508 {
509 if (mixer_ehtag != NULL)
510 EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag);
511 }
512
513 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL);
514 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL);
515 #endif
516
517
Cache object: 5e015a9c5df4586f2fc485fa34b04354
|