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 dev_ops_add(&mixer_cdevsw, -1, PCMMKMINOR(unit, SND_DEV_CTL, 0)); 368 pdev = make_dev(&mixer_cdevsw, PCMMKMINOR(unit, SND_DEV_CTL, 0), 369 UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit); 370 reference_dev(pdev); 371 pdev->si_drv1 = m; 372 snddev = device_get_softc(dev); 373 snddev->mixer_dev = pdev; 374 375 if (bootverbose) { 376 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 377 if (!(m->devs & (1 << i))) 378 continue; 379 if (m->realdev[i] != i) { 380 device_printf(dev, "Mixer \"%s\" -> \"%s\":", 381 snd_mixernames[i], 382 (m->realdev[i] < SOUND_MIXER_NRDEVICES) ? 383 snd_mixernames[m->realdev[i]] : "none"); 384 } else { 385 device_printf(dev, "Mixer \"%s\":", 386 snd_mixernames[i]); 387 } 388 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 389 kprintf(" parent=\"%s\"", 390 snd_mixernames[m->parent[i]]); 391 if (m->child[i] != 0) 392 kprintf(" child=0x%08x", m->child[i]); 393 kprintf("\n"); 394 } 395 if (snddev->flags & SD_F_SOFTPCMVOL) 396 device_printf(dev, "Soft PCM mixer ENABLED\n"); 397 } 398 399 return 0; 400 401 bad: 402 snd_mtxfree(m->lock); 403 kobj_delete((kobj_t)m, M_MIXER); 404 return -1; 405 } 406 407 int 408 mixer_uninit(device_t dev) 409 { 410 int i; 411 int unit; 412 struct snddev_info *d; 413 struct snd_mixer *m; 414 struct cdev *pdev; 415 416 d = device_get_softc(dev); 417 pdev = mixer_get_devt(dev); 418 if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL) 419 return EBADF; 420 m = pdev->si_drv1; 421 snd_mtxlock(m->lock); 422 423 if (m->busy) { 424 snd_mtxunlock(m->lock); 425 return EBUSY; 426 } 427 428 pdev->si_drv1 = NULL; 429 release_dev(pdev); 430 unit = device_get_unit(dev); 431 dev_ops_remove(&mixer_cdevsw, -1, PCMMKMINOR(unit, SND_DEV_CTL, 0)); 432 433 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 434 mixer_set(m, i, 0); 435 436 mixer_setrecsrc(m, SOUND_MASK_MIC); 437 438 MIXER_UNINIT(m); 439 440 snd_mtxunlock(m->lock); 441 snd_mtxfree(m->lock); 442 kobj_delete((kobj_t)m, M_MIXER); 443 444 d->mixer_dev = NULL; 445 446 return 0; 447 } 448 449 int 450 mixer_reinit(device_t dev) 451 { 452 struct snd_mixer *m; 453 struct cdev *pdev; 454 int i; 455 456 pdev = mixer_get_devt(dev); 457 m = pdev->si_drv1; 458 snd_mtxlock(m->lock); 459 460 i = MIXER_REINIT(m); 461 if (i) { 462 snd_mtxunlock(m->lock); 463 return i; 464 } 465 466 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 467 mixer_set(m, i, m->level[i]); 468 469 mixer_setrecsrc(m, m->recsrc); 470 snd_mtxunlock(m->lock); 471 472 return 0; 473 } 474 475 #ifdef SND_DYNSYSCTL 476 static int 477 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS) 478 { 479 char devname[32]; 480 int error, dev; 481 struct snd_mixer *m; 482 483 m = oidp->oid_arg1; 484 snd_mtxlock(m->lock); 485 strncpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname)); 486 snd_mtxunlock(m->lock); 487 error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req); 488 snd_mtxlock(m->lock); 489 if (error == 0 && req->newptr != NULL) { 490 dev = mixer_lookup(devname); 491 if (dev == -1) { 492 snd_mtxunlock(m->lock); 493 return EINVAL; 494 } 495 else if (dev != m->hwvol_mixer) { 496 m->hwvol_mixer = dev; 497 m->hwvol_muted = 0; 498 } 499 } 500 snd_mtxunlock(m->lock); 501 return error; 502 } 503 #endif 504 505 int 506 mixer_hwvol_init(device_t dev) 507 { 508 struct snd_mixer *m; 509 struct cdev *pdev; 510 511 pdev = mixer_get_devt(dev); 512 m = pdev->si_drv1; 513 514 m->hwvol_mixer = SOUND_MIXER_VOLUME; 515 m->hwvol_step = 5; 516 #ifdef SND_DYNSYSCTL 517 SYSCTL_ADD_INT(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)), 518 OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, ""); 519 SYSCTL_ADD_PROC(snd_sysctl_tree(dev), SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)), 520 OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0, 521 sysctl_hw_snd_hwvol_mixer, "A", ""); 522 #endif 523 return 0; 524 } 525 526 void 527 mixer_hwvol_mute(device_t dev) 528 { 529 struct snd_mixer *m; 530 struct cdev *pdev; 531 532 pdev = mixer_get_devt(dev); 533 m = pdev->si_drv1; 534 snd_mtxlock(m->lock); 535 if (m->hwvol_muted) { 536 m->hwvol_muted = 0; 537 mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level); 538 } else { 539 m->hwvol_muted++; 540 m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer); 541 mixer_set(m, m->hwvol_mixer, 0); 542 } 543 snd_mtxunlock(m->lock); 544 } 545 546 void 547 mixer_hwvol_step(device_t dev, int left_step, int right_step) 548 { 549 struct snd_mixer *m; 550 int level, left, right; 551 struct cdev *pdev; 552 553 pdev = mixer_get_devt(dev); 554 m = pdev->si_drv1; 555 snd_mtxlock(m->lock); 556 if (m->hwvol_muted) { 557 m->hwvol_muted = 0; 558 level = m->hwvol_mute_level; 559 } else 560 level = mixer_get(m, m->hwvol_mixer); 561 if (level != -1) { 562 left = level & 0xff; 563 right = level >> 8; 564 left += left_step * m->hwvol_step; 565 if (left < 0) 566 left = 0; 567 right += right_step * m->hwvol_step; 568 if (right < 0) 569 right = 0; 570 mixer_set(m, m->hwvol_mixer, left | right << 8); 571 } 572 snd_mtxunlock(m->lock); 573 } 574 575 /* ----------------------------------------------------------------------- */ 576 577 static int 578 vchanvolume(cdev_t i_dev, int write, int *volume, int *ret, 579 struct thread *td) 580 { 581 struct snddev_info *d; 582 void *cookie; 583 struct pcm_channel *ch; 584 int vol_left, vol_right; 585 586 crit_enter(); 587 d = dsp_get_info(i_dev); 588 if (d == NULL) { 589 crit_exit(); 590 return 0; 591 } 592 /* 593 * We search for a vchan which is owned by the current process. 594 */ 595 for (cookie = NULL; (ch = pcm_chn_iterate(d, &cookie)) != NULL;) 596 if (ch->flags & CHN_F_VIRTUAL && 597 ch->pid == td->td_proc->p_pid) 598 break; 599 600 if (ch == NULL) { 601 crit_exit(); 602 return 0; 603 } 604 605 if (write) { 606 vol_left = min(*volume & 0x00ff, 100); 607 vol_right = min((*volume & 0xff00) >> 8, 100); 608 *ret = chn_setvolume(ch, vol_left, vol_right); 609 } else { 610 *volume = ch->volume; 611 *ret = 0; 612 } 613 crit_exit(); 614 return 1; 615 } 616 617 /* ----------------------------------------------------------------------- */ 618 619 static int 620 mixer_open(struct dev_open_args *ap) 621 { 622 struct cdev *i_dev = ap->a_head.a_dev; 623 struct snd_mixer *m; 624 625 m = i_dev->si_drv1; 626 snd_mtxlock(m->lock); 627 628 m->busy++; 629 630 snd_mtxunlock(m->lock); 631 return 0; 632 } 633 634 static int 635 mixer_close(struct dev_close_args *ap) 636 { 637 struct cdev *i_dev = ap->a_head.a_dev; 638 struct snd_mixer *m; 639 640 m = i_dev->si_drv1; 641 snd_mtxlock(m->lock); 642 643 if (!m->busy) { 644 snd_mtxunlock(m->lock); 645 return EBADF; 646 } 647 m->busy--; 648 649 snd_mtxunlock(m->lock); 650 return 0; 651 } 652 653 int 654 mixer_ioctl(struct dev_ioctl_args *ap) 655 { 656 struct cdev *i_dev = ap->a_head.a_dev; 657 u_long cmd = ap->a_cmd; 658 caddr_t arg = ap->a_data; 659 int mode = ap->a_fflag; 660 struct snd_mixer *m; 661 int ret, *arg_i = (int *)arg; 662 int v = -1, j = cmd & 0xff; 663 664 m = i_dev->si_drv1; 665 666 if (m == NULL) 667 return EBADF; 668 669 /* 670 * If we are handling PCM, maybe the app really wants to 671 * set its vchan, and fails to use the correct fd. 672 */ 673 if (j == SOUND_MIXER_PCM) { 674 if (vchanvolume(i_dev, 675 (cmd & MIXER_WRITE(0)) == MIXER_WRITE(0), 676 (int *)arg, &ret, curthread)) 677 return ret; 678 /* else proceed as usual */ 679 } 680 681 snd_mtxlock(m->lock); 682 if (mode != -1 && !m->busy) { 683 snd_mtxunlock(m->lock); 684 return EBADF; 685 } 686 687 if ((cmd & MIXER_WRITE(0)) == MIXER_WRITE(0)) { 688 if (j == SOUND_MIXER_RECSRC) 689 ret = mixer_setrecsrc(m, *arg_i); 690 else 691 ret = mixer_set(m, j, *arg_i); 692 snd_mtxunlock(m->lock); 693 return (ret == 0)? 0 : ENXIO; 694 } 695 696 if ((cmd & MIXER_READ(0)) == MIXER_READ(0)) { 697 switch (j) { 698 case SOUND_MIXER_DEVMASK: 699 case SOUND_MIXER_CAPS: 700 case SOUND_MIXER_STEREODEVS: 701 v = mix_getdevs(m); 702 break; 703 704 case SOUND_MIXER_RECMASK: 705 v = mix_getrecdevs(m); 706 break; 707 708 case SOUND_MIXER_RECSRC: 709 v = mixer_getrecsrc(m); 710 break; 711 712 default: 713 v = mixer_get(m, j); 714 } 715 *arg_i = v; 716 snd_mtxunlock(m->lock); 717 return (v != -1)? 0 : ENXIO; 718 } 719 snd_mtxunlock(m->lock); 720 return ENXIO; 721 } 722 723 #ifdef USING_DEVFS 724 static void 725 mixer_clone(void *arg, struct ucred *cred, char *name, int namelen, 726 struct cdev **dev) 727 { 728 struct snddev_info *sd; 729 730 if (*dev != NULL) 731 return; 732 if (strcmp(name, "mixer") == 0) { 733 sd = devclass_get_softc(pcm_devclass, snd_unit); 734 if (sd != NULL && sd->mixer_dev != NULL) { 735 *dev = sd->mixer_dev; 736 dev_ref(*dev); 737 } 738 } 739 } 740 741 static void 742 mixer_sysinit(void *p) 743 { 744 mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000); 745 } 746 747 static void 748 mixer_sysuninit(void *p) 749 { 750 if (mixer_ehtag != NULL) 751 EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag); 752 } 753 754 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL); 755 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL); 756 #endif 757 758 759