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 * $FreeBSD: src/sys/dev/sound/pcm/mixer.c,v 1.43.2.5 2007/05/13 20:53:39 ariff Exp $ 27 * $DragonFly: src/sys/dev/sound/pcm/mixer.c,v 1.18 2007/06/22 21:41:16 corecode Exp $ 28 */ 29 30 #include <dev/sound/pcm/sound.h> 31 #include <dev/sound/pcm/dsp.h> 32 33 #include "mixer_if.h" 34 35 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/mixer.c,v 1.18 2007/06/22 21:41:16 corecode Exp $"); 36 37 MALLOC_DEFINE(M_MIXER, "mixer", "mixer"); 38 39 #define MIXER_NAMELEN 16 40 struct snd_mixer { 41 KOBJ_FIELDS; 42 const char *type; 43 void *devinfo; 44 int busy; 45 int hwvol_muted; 46 int hwvol_mixer; 47 int hwvol_step; 48 device_t dev; 49 u_int32_t hwvol_mute_level; 50 u_int32_t devs; 51 u_int32_t recdevs; 52 u_int32_t recsrc; 53 u_int16_t level[32]; 54 u_int8_t parent[32]; 55 u_int32_t child[32]; 56 u_int8_t realdev[32]; 57 char name[MIXER_NAMELEN]; 58 sndlock_t lock; 59 }; 60 61 static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = { 62 [SOUND_MIXER_VOLUME] = 75, 63 [SOUND_MIXER_BASS] = 50, 64 [SOUND_MIXER_TREBLE] = 50, 65 [SOUND_MIXER_SYNTH] = 75, 66 [SOUND_MIXER_PCM] = 75, 67 [SOUND_MIXER_SPEAKER] = 75, 68 [SOUND_MIXER_LINE] = 75, 69 [SOUND_MIXER_MIC] = 0, 70 [SOUND_MIXER_CD] = 75, 71 [SOUND_MIXER_IGAIN] = 0, 72 [SOUND_MIXER_LINE1] = 75, 73 [SOUND_MIXER_VIDEO] = 75, 74 [SOUND_MIXER_RECLEV] = 0, 75 [SOUND_MIXER_OGAIN] = 50, 76 [SOUND_MIXER_MONITOR] = 75, 77 }; 78 79 static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES; 80 81 static d_open_t mixer_open; 82 static d_close_t mixer_close; 83 84 static struct dev_ops mixer_cdevsw = { 85 { "mixer", SND_CDEV_MAJOR, D_TRACKCLOSE }, 86 /* .d_flags = D_TRACKCLOSE | D_NEEDGIANT, */ 87 .d_open = mixer_open, 88 .d_close = mixer_close, 89 .d_ioctl = mixer_ioctl, 90 }; 91 92 #ifdef USING_DEVFS 93 static eventhandler_tag mixer_ehtag; 94 #endif 95 96 static struct cdev * 97 mixer_get_devt(device_t dev) 98 { 99 struct snddev_info *snddev; 100 101 snddev = device_get_softc(dev); 102 103 return snddev->mixer_dev; 104 } 105 106 #ifdef SND_DYNSYSCTL 107 static int 108 mixer_lookup(char *devname) 109 { 110 int i; 111 112 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 113 if (strncmp(devname, snd_mixernames[i], 114 strlen(snd_mixernames[i])) == 0) 115 return i; 116 return -1; 117 } 118 #endif 119 120 /* 121 * Always called with mixer->lock held. 122 */ 123 static int 124 mixer_set_softpcmvol(struct snd_mixer *mixer, struct snddev_info *d, 125 unsigned left, unsigned right) 126 { 127 struct snddev_channel *sce; 128 struct pcm_channel *ch; 129 130 snd_mtxunlock(mixer->lock); 131 SLIST_FOREACH(sce, &d->channels, link) { 132 ch = sce->channel; 133 CHN_LOCK(ch); 134 if (ch->direction == PCMDIR_PLAY && 135 (ch->feederflags & (1 << FEEDER_VOLUME))) 136 chn_setvolume(ch, left, right); 137 CHN_UNLOCK(ch); 138 } 139 snd_mtxlock(mixer->lock); 140 return 0; 141 } 142 143 static int 144 mixer_set(struct snd_mixer *m, unsigned dev, unsigned lev) 145 { 146 struct snddev_info *d; 147 unsigned l, r, tl, tr; 148 u_int32_t parent = SOUND_MIXER_NONE, child = 0; 149 u_int32_t realdev; 150 int i; 151 152 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES || 153 (0 == (m->devs & (1 << dev)))) 154 return -1; 155 156 l = min((lev & 0x00ff), 100); 157 r = min(((lev & 0xff00) >> 8), 100); 158 realdev = m->realdev[dev]; 159 160 d = device_get_softc(m->dev); 161 if (d == NULL) 162 return -1; 163 164 /* TODO: recursive handling */ 165 parent = m->parent[dev]; 166 if (parent >= SOUND_MIXER_NRDEVICES) 167 parent = SOUND_MIXER_NONE; 168 if (parent == SOUND_MIXER_NONE) 169 child = m->child[dev]; 170 171 if (parent != SOUND_MIXER_NONE) { 172 tl = (l * (m->level[parent] & 0x00ff)) / 100; 173 tr = (r * ((m->level[parent] & 0xff00) >> 8)) / 100; 174 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) 175 mixer_set_softpcmvol(m, d, tl, tr); 176 else if (realdev != SOUND_MIXER_NONE && 177 MIXER_SET(m, realdev, tl, tr) < 0) 178 return -1; 179 } else if (child != 0) { 180 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 181 if (!(child & (1 << i)) || m->parent[i] != dev) 182 continue; 183 realdev = m->realdev[i]; 184 tl = (l * (m->level[i] & 0x00ff)) / 100; 185 tr = (r * ((m->level[i] & 0xff00) >> 8)) / 100; 186 if (i == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) 187 mixer_set_softpcmvol(m, d, tl, tr); 188 else if (realdev != SOUND_MIXER_NONE) 189 MIXER_SET(m, realdev, tl, tr); 190 } 191 realdev = m->realdev[dev]; 192 if (realdev != SOUND_MIXER_NONE && 193 MIXER_SET(m, realdev, l, r) < 0) 194 return -1; 195 } else { 196 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) 197 mixer_set_softpcmvol(m, d, l, r); 198 else if (realdev != SOUND_MIXER_NONE && 199 MIXER_SET(m, realdev, l, r) < 0) 200 return -1; 201 } 202 203 m->level[dev] = l | (r << 8); 204 205 return 0; 206 } 207 208 static int 209 mixer_get(struct snd_mixer *mixer, int dev) 210 { 211 if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev))) 212 return mixer->level[dev]; 213 else return -1; 214 } 215 216 static int 217 mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src) 218 { 219 src &= mixer->recdevs; 220 if (src == 0) 221 src = SOUND_MASK_MIC; 222 mixer->recsrc = MIXER_SETRECSRC(mixer, src); 223 return 0; 224 } 225 226 static int 227 mixer_getrecsrc(struct snd_mixer *mixer) 228 { 229 return mixer->recsrc; 230 } 231 232 void 233 mix_setdevs(struct snd_mixer *m, u_int32_t v) 234 { 235 struct snddev_info *d; 236 int i; 237 238 if (m == NULL) 239 return; 240 241 d = device_get_softc(m->dev); 242 if (d != NULL && (d->flags & SD_F_SOFTPCMVOL)) 243 v |= SOUND_MASK_PCM; 244 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 245 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 246 v |= 1 << m->parent[i]; 247 v |= m->child[i]; 248 } 249 m->devs = v; 250 } 251 252 void 253 mix_setrecdevs(struct snd_mixer *m, u_int32_t v) 254 { 255 m->recdevs = v; 256 } 257 258 void 259 mix_setparentchild(struct snd_mixer *m, u_int32_t parent, u_int32_t childs) 260 { 261 u_int32_t mask = 0; 262 int i; 263 264 if (m == NULL || parent >= SOUND_MIXER_NRDEVICES) 265 return; 266 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 267 if (i == parent) 268 continue; 269 if (childs & (1 << i)) { 270 mask |= 1 << i; 271 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 272 m->child[m->parent[i]] &= ~(1 << i); 273 m->parent[i] = parent; 274 m->child[i] = 0; 275 } 276 } 277 mask &= ~(1 << parent); 278 m->child[parent] = mask; 279 } 280 281 void 282 mix_setrealdev(struct snd_mixer *m, u_int32_t dev, u_int32_t realdev) 283 { 284 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES || 285 !(realdev == SOUND_MIXER_NONE || realdev < SOUND_MIXER_NRDEVICES)) 286 return; 287 m->realdev[dev] = realdev; 288 } 289 290 u_int32_t 291 mix_getparent(struct snd_mixer *m, u_int32_t dev) 292 { 293 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES) 294 return SOUND_MIXER_NONE; 295 return m->parent[dev]; 296 } 297 298 u_int32_t 299 mix_getchild(struct snd_mixer *m, u_int32_t dev) 300 { 301 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES) 302 return 0; 303 return m->child[dev]; 304 } 305 306 u_int32_t 307 mix_getdevs(struct snd_mixer *m) 308 { 309 return m->devs; 310 } 311 312 u_int32_t 313 mix_getrecdevs(struct snd_mixer *m) 314 { 315 return m->recdevs; 316 } 317 318 void * 319 mix_getdevinfo(struct snd_mixer *m) 320 { 321 return m->devinfo; 322 } 323 324 int 325 mixer_init(device_t dev, kobj_class_t cls, void *devinfo) 326 { 327 struct snddev_info *snddev; 328 struct snd_mixer *m; 329 u_int16_t v; 330 struct cdev *pdev; 331 int i, unit, val; 332 333 m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO); 334 ksnprintf(m->name, MIXER_NAMELEN, "%s:mixer", device_get_nameunit(dev)); 335 m->lock = snd_mtxcreate(m->name, "pcm mixer"); 336 m->type = cls->name; 337 m->devinfo = devinfo; 338 m->busy = 0; 339 m->dev = dev; 340 for (i = 0; i < 32; i++) { 341 m->parent[i] = SOUND_MIXER_NONE; 342 m->child[i] = 0; 343 m->realdev[i] = i; 344 } 345 346 if (MIXER_INIT(m)) 347 goto bad; 348 349 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 350 v = snd_mixerdefaults[i]; 351 352 if (resource_int_value(device_get_name(dev), 353 device_get_unit(dev), snd_mixernames[i], &val) == 0) { 354 if (val >= 0 && val <= 100) { 355 v = (u_int16_t) val; 356 } 357 } 358 359 snd_mtxlock(m->lock); 360 mixer_set(m, i, v | (v << 8)); 361 snd_mtxunlock(m->lock); 362 } 363 364 mixer_setrecsrc(m, SOUND_MASK_MIC); 365 366 unit = device_get_unit(dev); 367 pdev = make_dev(&mixer_cdevsw, PCMMKMINOR(unit, 0), 368 UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit); 369 reference_dev(pdev); 370 pdev->si_drv1 = m; 371 snddev = device_get_softc(dev); 372 snddev->mixer_dev = pdev; 373 374 if (bootverbose) { 375 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 376 if (!(m->devs & (1 << i))) 377 continue; 378 if (m->realdev[i] != i) { 379 device_printf(dev, "Mixer \"%s\" -> \"%s\":", 380 snd_mixernames[i], 381 (m->realdev[i] < SOUND_MIXER_NRDEVICES) ? 382 snd_mixernames[m->realdev[i]] : "none"); 383 } else { 384 device_printf(dev, "Mixer \"%s\":", 385 snd_mixernames[i]); 386 } 387 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 388 kprintf(" parent=\"%s\"", 389 snd_mixernames[m->parent[i]]); 390 if (m->child[i] != 0) 391 kprintf(" child=0x%08x", m->child[i]); 392 kprintf("\n"); 393 } 394 if (snddev->flags & SD_F_SOFTPCMVOL) 395 device_printf(dev, "Soft PCM mixer ENABLED\n"); 396 } 397 398 return 0; 399 400 bad: 401 snd_mtxfree(m->lock); 402 kobj_delete((kobj_t)m, M_MIXER); 403 return -1; 404 } 405 406 int 407 mixer_uninit(device_t dev) 408 { 409 int i; 410 int unit; 411 struct snddev_info *d; 412 struct snd_mixer *m; 413 struct cdev *pdev; 414 415 d = device_get_softc(dev); 416 pdev = mixer_get_devt(dev); 417 if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL) 418 return EBADF; 419 m = pdev->si_drv1; 420 snd_mtxlock(m->lock); 421 422 if (m->busy) { 423 snd_mtxunlock(m->lock); 424 return EBUSY; 425 } 426 427 pdev->si_drv1 = NULL; 428 release_dev(pdev); 429 unit = device_get_unit(dev); 430 dev_ops_remove_minor(&mixer_cdevsw, /*-1, */PCMMKMINOR(unit, 0)); 431 432 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 433 mixer_set(m, i, 0); 434 435 mixer_setrecsrc(m, SOUND_MASK_MIC); 436 437 MIXER_UNINIT(m); 438 439 snd_mtxunlock(m->lock); 440 snd_mtxfree(m->lock); 441 kobj_delete((kobj_t)m, M_MIXER); 442 443 d->mixer_dev = NULL; 444 445 return 0; 446 } 447 448 int 449 mixer_reinit(device_t dev) 450 { 451 struct snd_mixer *m; 452 struct cdev *pdev; 453 int i; 454 455 pdev = mixer_get_devt(dev); 456 m = pdev->si_drv1; 457 snd_mtxlock(m->lock); 458 459 i = MIXER_REINIT(m); 460 if (i) { 461 snd_mtxunlock(m->lock); 462 return i; 463 } 464 465 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 466 mixer_set(m, i, m->level[i]); 467 468 mixer_setrecsrc(m, m->recsrc); 469 snd_mtxunlock(m->lock); 470 471 return 0; 472 } 473 474 #ifdef SND_DYNSYSCTL 475 static int 476 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS) 477 { 478 char devname[32]; 479 int error, dev; 480 struct snd_mixer *m; 481 482 m = oidp->oid_arg1; 483 snd_mtxlock(m->lock); 484 strncpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname)); 485 snd_mtxunlock(m->lock); 486 error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req); 487 snd_mtxlock(m->lock); 488 if (error == 0 && req->newptr != NULL) { 489 dev = mixer_lookup(devname); 490 if (dev == -1) { 491 snd_mtxunlock(m->lock); 492 return EINVAL; 493 } 494 else if (dev != m->hwvol_mixer) { 495 m->hwvol_mixer = dev; 496 m->hwvol_muted = 0; 497 } 498 } 499 snd_mtxunlock(m->lock); 500 return error; 501 } 502 #endif 503 504 int 505 mixer_hwvol_init(device_t dev) 506 { 507 struct snd_mixer *m; 508 struct cdev *pdev; 509 510 pdev = mixer_get_devt(dev); 511 m = pdev->si_drv1; 512 513 m->hwvol_mixer = SOUND_MIXER_VOLUME; 514 m->hwvol_step = 5; 515 #ifdef SND_DYNSYSCTL 516 SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)), 517 OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, ""); 518 SYSCTL_ADD_PROC(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)), 519 OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0, 520 sysctl_hw_snd_hwvol_mixer, "A", ""); 521 #endif 522 return 0; 523 } 524 525 void 526 mixer_hwvol_mute(device_t dev) 527 { 528 struct snd_mixer *m; 529 struct cdev *pdev; 530 531 pdev = mixer_get_devt(dev); 532 m = pdev->si_drv1; 533 snd_mtxlock(m->lock); 534 if (m->hwvol_muted) { 535 m->hwvol_muted = 0; 536 mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level); 537 } else { 538 m->hwvol_muted++; 539 m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer); 540 mixer_set(m, m->hwvol_mixer, 0); 541 } 542 snd_mtxunlock(m->lock); 543 } 544 545 void 546 mixer_hwvol_step(device_t dev, int left_step, int right_step) 547 { 548 struct snd_mixer *m; 549 int level, left, right; 550 struct cdev *pdev; 551 552 pdev = mixer_get_devt(dev); 553 m = pdev->si_drv1; 554 snd_mtxlock(m->lock); 555 if (m->hwvol_muted) { 556 m->hwvol_muted = 0; 557 level = m->hwvol_mute_level; 558 } else 559 level = mixer_get(m, m->hwvol_mixer); 560 if (level != -1) { 561 left = level & 0xff; 562 right = level >> 8; 563 left += left_step * m->hwvol_step; 564 if (left < 0) 565 left = 0; 566 right += right_step * m->hwvol_step; 567 if (right < 0) 568 right = 0; 569 mixer_set(m, m->hwvol_mixer, left | right << 8); 570 } 571 snd_mtxunlock(m->lock); 572 } 573 574 /* ----------------------------------------------------------------------- */ 575 576 static int 577 vchanvolume(cdev_t i_dev, int write, int *volume, int *ret, 578 struct thread *td) 579 { 580 struct snddev_info *d; 581 void *cookie; 582 struct pcm_channel *ch; 583 int vol_left, vol_right; 584 585 crit_enter(); 586 d = dsp_get_info(i_dev); 587 if (d == NULL) { 588 crit_exit(); 589 return 0; 590 } 591 /* 592 * We search for a vchan which is owned by the current process. 593 */ 594 for (cookie = NULL; (ch = pcm_chn_iterate(d, &cookie)) != NULL;) 595 if (ch->flags & CHN_F_VIRTUAL && 596 ch->pid == td->td_proc->p_pid) 597 break; 598 599 if (ch == NULL) { 600 crit_exit(); 601 return 0; 602 } 603 604 if (write) { 605 vol_left = min(*volume & 0x00ff, 100); 606 vol_right = min((*volume & 0xff00) >> 8, 100); 607 *ret = chn_setvolume(ch, vol_left, vol_right); 608 } else { 609 *volume = ch->volume; 610 *ret = 0; 611 } 612 crit_exit(); 613 return 1; 614 } 615 616 /* ----------------------------------------------------------------------- */ 617 618 static int 619 mixer_open(struct dev_open_args *ap) 620 { 621 struct cdev *i_dev = ap->a_head.a_dev; 622 struct snd_mixer *m; 623 624 m = i_dev->si_drv1; 625 snd_mtxlock(m->lock); 626 627 m->busy++; 628 629 snd_mtxunlock(m->lock); 630 return 0; 631 } 632 633 static int 634 mixer_close(struct dev_close_args *ap) 635 { 636 struct cdev *i_dev = ap->a_head.a_dev; 637 struct snd_mixer *m; 638 639 m = i_dev->si_drv1; 640 snd_mtxlock(m->lock); 641 642 if (!m->busy) { 643 snd_mtxunlock(m->lock); 644 return EBADF; 645 } 646 m->busy--; 647 648 snd_mtxunlock(m->lock); 649 return 0; 650 } 651 652 int 653 mixer_ioctl(struct dev_ioctl_args *ap) 654 { 655 struct cdev *i_dev = ap->a_head.a_dev; 656 u_long cmd = ap->a_cmd; 657 caddr_t arg = ap->a_data; 658 int mode = ap->a_fflag; 659 struct snd_mixer *m; 660 int ret, *arg_i = (int *)arg; 661 int v = -1, j = cmd & 0xff; 662 663 m = i_dev->si_drv1; 664 665 if (m == NULL) 666 return EBADF; 667 668 /* 669 * If we are handling PCM, maybe the app really wants to 670 * set its vchan, and fails to use the correct fd. 671 */ 672 if (j == SOUND_MIXER_PCM) { 673 if (vchanvolume(i_dev, 674 (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0), 675 (int *)arg, &ret, curthread)) 676 return ret; 677 /* else proceed as usual */ 678 } 679 680 snd_mtxlock(m->lock); 681 if (mode != -1 && !m->busy) { 682 snd_mtxunlock(m->lock); 683 return EBADF; 684 } 685 686 if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) { 687 if (j == SOUND_MIXER_RECSRC) 688 ret = mixer_setrecsrc(m, *arg_i); 689 else 690 ret = mixer_set(m, j, *arg_i); 691 snd_mtxunlock(m->lock); 692 return (ret == 0)? 0 : ENXIO; 693 } 694 695 if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) { 696 switch (j) { 697 case SOUND_MIXER_DEVMASK: 698 case SOUND_MIXER_CAPS: 699 case SOUND_MIXER_STEREODEVS: 700 v = mix_getdevs(m); 701 break; 702 703 case SOUND_MIXER_RECMASK: 704 v = mix_getrecdevs(m); 705 break; 706 707 case SOUND_MIXER_RECSRC: 708 v = mixer_getrecsrc(m); 709 break; 710 711 default: 712 v = mixer_get(m, j); 713 } 714 *arg_i = v; 715 snd_mtxunlock(m->lock); 716 return (v != -1)? 0 : ENXIO; 717 } 718 snd_mtxunlock(m->lock); 719 return ENXIO; 720 } 721 722 #ifdef USING_DEVFS 723 static void 724 mixer_clone(void *arg, struct ucred *cred, char *name, int namelen, 725 struct cdev **dev) 726 { 727 struct snddev_info *sd; 728 729 if (*dev != NULL) 730 return; 731 if (strcmp(name, "mixer") == 0) { 732 sd = devclass_get_softc(pcm_devclass, snd_unit); 733 if (sd != NULL && sd->mixer_dev != NULL) { 734 *dev = sd->mixer_dev; 735 dev_ref(*dev); 736 } 737 } 738 } 739 740 static void 741 mixer_sysinit(void *p) 742 { 743 mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000); 744 } 745 746 static void 747 mixer_sysuninit(void *p) 748 { 749 if (mixer_ehtag != NULL) 750 EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag); 751 } 752 753 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL); 754 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL); 755 #endif 756 757 758