Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/pcm/mixer.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org> 3 * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006 4 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #ifdef HAVE_KERNEL_OPTION_HEADERS 30 #include "opt_snd.h" 31 #endif 32 33 #include <dev/sound/pcm/sound.h> 34 35 #include "feeder_if.h" 36 #include "mixer_if.h" 37 38 SND_DECLARE_FILE("$FreeBSD$"); 39 40 static MALLOC_DEFINE(M_MIXER, "mixer", "mixer"); 41 42 static int mixer_bypass = 1; 43 TUNABLE_INT("hw.snd.vpc_mixer_bypass", &mixer_bypass); 44 SYSCTL_INT(_hw_snd, OID_AUTO, vpc_mixer_bypass, CTLFLAG_RW, 45 &mixer_bypass, 0, 46 "control channel pcm/rec volume, bypassing real mixer device"); 47 48 #define MIXER_NAMELEN 16 49 struct snd_mixer { 50 KOBJ_FIELDS; 51 void *devinfo; 52 int busy; 53 int hwvol_muted; 54 int hwvol_mixer; 55 int hwvol_step; 56 int type; 57 device_t dev; 58 u_int32_t hwvol_mute_level; 59 u_int32_t devs; 60 u_int32_t recdevs; 61 u_int32_t recsrc; 62 u_int16_t level[32]; 63 u_int8_t parent[32]; 64 u_int32_t child[32]; 65 u_int8_t realdev[32]; 66 char name[MIXER_NAMELEN]; 67 struct mtx *lock; 68 oss_mixer_enuminfo enuminfo; 69 /** 70 * Counter is incremented when applications change any of this 71 * mixer's controls. A change in value indicates that persistent 72 * mixer applications should update their displays. 73 */ 74 int modify_counter; 75 }; 76 77 static u_int16_t snd_mixerdefaults[SOUND_MIXER_NRDEVICES] = { 78 [SOUND_MIXER_VOLUME] = 75, 79 [SOUND_MIXER_BASS] = 50, 80 [SOUND_MIXER_TREBLE] = 50, 81 [SOUND_MIXER_SYNTH] = 75, 82 [SOUND_MIXER_PCM] = 75, 83 [SOUND_MIXER_SPEAKER] = 75, 84 [SOUND_MIXER_LINE] = 75, 85 [SOUND_MIXER_MIC] = 25, 86 [SOUND_MIXER_CD] = 75, 87 [SOUND_MIXER_IGAIN] = 0, 88 [SOUND_MIXER_LINE1] = 75, 89 [SOUND_MIXER_VIDEO] = 75, 90 [SOUND_MIXER_RECLEV] = 75, 91 [SOUND_MIXER_OGAIN] = 50, 92 [SOUND_MIXER_MONITOR] = 75, 93 }; 94 95 static char* snd_mixernames[SOUND_MIXER_NRDEVICES] = SOUND_DEVICE_NAMES; 96 97 static d_open_t mixer_open; 98 static d_close_t mixer_close; 99 static d_ioctl_t mixer_ioctl; 100 101 static struct cdevsw mixer_cdevsw = { 102 .d_version = D_VERSION, 103 .d_open = mixer_open, 104 .d_close = mixer_close, 105 .d_ioctl = mixer_ioctl, 106 .d_name = "mixer", 107 }; 108 109 /** 110 * Keeps a count of mixer devices; used only by OSSv4 SNDCTL_SYSINFO ioctl. 111 */ 112 int mixer_count = 0; 113 114 static eventhandler_tag mixer_ehtag = NULL; 115 116 static struct cdev * 117 mixer_get_devt(device_t dev) 118 { 119 struct snddev_info *snddev; 120 121 snddev = device_get_softc(dev); 122 123 return snddev->mixer_dev; 124 } 125 126 static int 127 mixer_lookup(char *devname) 128 { 129 int i; 130 131 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 132 if (strncmp(devname, snd_mixernames[i], 133 strlen(snd_mixernames[i])) == 0) 134 return i; 135 return -1; 136 } 137 138 #define MIXER_SET_UNLOCK(x, y) do { \ 139 if ((y) != 0) \ 140 snd_mtxunlock((x)->lock); \ 141 } while (0) 142 143 #define MIXER_SET_LOCK(x, y) do { \ 144 if ((y) != 0) \ 145 snd_mtxlock((x)->lock); \ 146 } while (0) 147 148 static int 149 mixer_set_softpcmvol(struct snd_mixer *m, struct snddev_info *d, 150 u_int left, u_int right) 151 { 152 struct pcm_channel *c; 153 int dropmtx, acquiremtx; 154 155 if (PCM_DETACHING(d) || !PCM_REGISTERED(d)) 156 return (EINVAL); 157 158 if (mtx_owned(m->lock)) 159 dropmtx = 1; 160 else 161 dropmtx = 0; 162 163 if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0) 164 acquiremtx = 0; 165 else 166 acquiremtx = 1; 167 168 /* 169 * Be careful here. If we're coming from cdev ioctl, it is OK to 170 * not doing locking AT ALL (except on individual channel) since 171 * we've been heavily guarded by pcm cv, or if we're still 172 * under Giant influence. Since we also have mix_* calls, we cannot 173 * assume such protection and just do the lock as usuall. 174 */ 175 MIXER_SET_UNLOCK(m, dropmtx); 176 MIXER_SET_LOCK(d, acquiremtx); 177 178 CHN_FOREACH(c, d, channels.pcm.busy) { 179 CHN_LOCK(c); 180 if (c->direction == PCMDIR_PLAY && 181 (c->feederflags & (1 << FEEDER_VOLUME))) 182 chn_setvolume_multi(c, SND_VOL_C_MASTER, left, right, 183 (left + right) >> 1); 184 CHN_UNLOCK(c); 185 } 186 187 MIXER_SET_UNLOCK(d, acquiremtx); 188 MIXER_SET_LOCK(m, dropmtx); 189 190 return (0); 191 } 192 193 static int 194 mixer_set_eq(struct snd_mixer *m, struct snddev_info *d, 195 u_int dev, u_int level) 196 { 197 struct pcm_channel *c; 198 struct pcm_feeder *f; 199 int tone, dropmtx, acquiremtx; 200 201 if (dev == SOUND_MIXER_TREBLE) 202 tone = FEEDEQ_TREBLE; 203 else if (dev == SOUND_MIXER_BASS) 204 tone = FEEDEQ_BASS; 205 else 206 return (EINVAL); 207 208 if (PCM_DETACHING(d) || !PCM_REGISTERED(d)) 209 return (EINVAL); 210 211 if (mtx_owned(m->lock)) 212 dropmtx = 1; 213 else 214 dropmtx = 0; 215 216 if (!(d->flags & SD_F_MPSAFE) || mtx_owned(d->lock) != 0) 217 acquiremtx = 0; 218 else 219 acquiremtx = 1; 220 221 /* 222 * Be careful here. If we're coming from cdev ioctl, it is OK to 223 * not doing locking AT ALL (except on individual channel) since 224 * we've been heavily guarded by pcm cv, or if we're still 225 * under Giant influence. Since we also have mix_* calls, we cannot 226 * assume such protection and just do the lock as usuall. 227 */ 228 MIXER_SET_UNLOCK(m, dropmtx); 229 MIXER_SET_LOCK(d, acquiremtx); 230 231 CHN_FOREACH(c, d, channels.pcm.busy) { 232 CHN_LOCK(c); 233 f = chn_findfeeder(c, FEEDER_EQ); 234 if (f != NULL) 235 (void)FEEDER_SET(f, tone, level); 236 CHN_UNLOCK(c); 237 } 238 239 MIXER_SET_UNLOCK(d, acquiremtx); 240 MIXER_SET_LOCK(m, dropmtx); 241 242 return (0); 243 } 244 245 static int 246 mixer_set(struct snd_mixer *m, u_int dev, u_int lev) 247 { 248 struct snddev_info *d; 249 u_int l, r, tl, tr; 250 u_int32_t parent = SOUND_MIXER_NONE, child = 0; 251 u_int32_t realdev; 252 int i, dropmtx; 253 254 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES || 255 (0 == (m->devs & (1 << dev)))) 256 return -1; 257 258 l = min((lev & 0x00ff), 100); 259 r = min(((lev & 0xff00) >> 8), 100); 260 realdev = m->realdev[dev]; 261 262 d = device_get_softc(m->dev); 263 if (d == NULL) 264 return -1; 265 266 /* It is safe to drop this mutex due to Giant. */ 267 if (!(d->flags & SD_F_MPSAFE) && mtx_owned(m->lock) != 0) 268 dropmtx = 1; 269 else 270 dropmtx = 0; 271 272 MIXER_SET_UNLOCK(m, dropmtx); 273 274 /* TODO: recursive handling */ 275 parent = m->parent[dev]; 276 if (parent >= SOUND_MIXER_NRDEVICES) 277 parent = SOUND_MIXER_NONE; 278 if (parent == SOUND_MIXER_NONE) 279 child = m->child[dev]; 280 281 if (parent != SOUND_MIXER_NONE) { 282 tl = (l * (m->level[parent] & 0x00ff)) / 100; 283 tr = (r * ((m->level[parent] & 0xff00) >> 8)) / 100; 284 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) 285 (void)mixer_set_softpcmvol(m, d, tl, tr); 286 else if (realdev != SOUND_MIXER_NONE && 287 MIXER_SET(m, realdev, tl, tr) < 0) { 288 MIXER_SET_LOCK(m, dropmtx); 289 return -1; 290 } 291 } else if (child != 0) { 292 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 293 if (!(child & (1 << i)) || m->parent[i] != dev) 294 continue; 295 realdev = m->realdev[i]; 296 tl = (l * (m->level[i] & 0x00ff)) / 100; 297 tr = (r * ((m->level[i] & 0xff00) >> 8)) / 100; 298 if (i == SOUND_MIXER_PCM && 299 (d->flags & SD_F_SOFTPCMVOL)) 300 (void)mixer_set_softpcmvol(m, d, tl, tr); 301 else if (realdev != SOUND_MIXER_NONE) 302 MIXER_SET(m, realdev, tl, tr); 303 } 304 realdev = m->realdev[dev]; 305 if (realdev != SOUND_MIXER_NONE && 306 MIXER_SET(m, realdev, l, r) < 0) { 307 MIXER_SET_LOCK(m, dropmtx); 308 return -1; 309 } 310 } else { 311 if (dev == SOUND_MIXER_PCM && (d->flags & SD_F_SOFTPCMVOL)) 312 (void)mixer_set_softpcmvol(m, d, l, r); 313 else if ((dev == SOUND_MIXER_TREBLE || 314 dev == SOUND_MIXER_BASS) && (d->flags & SD_F_EQ)) 315 (void)mixer_set_eq(m, d, dev, (l + r) >> 1); 316 else if (realdev != SOUND_MIXER_NONE && 317 MIXER_SET(m, realdev, l, r) < 0) { 318 MIXER_SET_LOCK(m, dropmtx); 319 return -1; 320 } 321 } 322 323 MIXER_SET_LOCK(m, dropmtx); 324 325 m->level[dev] = l | (r << 8); 326 m->modify_counter++; 327 328 return 0; 329 } 330 331 static int 332 mixer_get(struct snd_mixer *mixer, int dev) 333 { 334 if ((dev < SOUND_MIXER_NRDEVICES) && (mixer->devs & (1 << dev))) 335 return mixer->level[dev]; 336 else 337 return -1; 338 } 339 340 static int 341 mixer_setrecsrc(struct snd_mixer *mixer, u_int32_t src) 342 { 343 struct snddev_info *d; 344 u_int32_t recsrc; 345 int dropmtx; 346 347 d = device_get_softc(mixer->dev); 348 if (d == NULL) 349 return -1; 350 if (!(d->flags & SD_F_MPSAFE) && mtx_owned(mixer->lock) != 0) 351 dropmtx = 1; 352 else 353 dropmtx = 0; 354 src &= mixer->recdevs; 355 if (src == 0) 356 src = mixer->recdevs & SOUND_MASK_MIC; 357 if (src == 0) 358 src = mixer->recdevs & SOUND_MASK_MONITOR; 359 if (src == 0) 360 src = mixer->recdevs & SOUND_MASK_LINE; 361 if (src == 0 && mixer->recdevs != 0) 362 src = (1 << (ffs(mixer->recdevs) - 1)); 363 /* It is safe to drop this mutex due to Giant. */ 364 MIXER_SET_UNLOCK(mixer, dropmtx); 365 recsrc = MIXER_SETRECSRC(mixer, src); 366 MIXER_SET_LOCK(mixer, dropmtx); 367 368 mixer->recsrc = recsrc; 369 370 return 0; 371 } 372 373 static int 374 mixer_getrecsrc(struct snd_mixer *mixer) 375 { 376 return mixer->recsrc; 377 } 378 379 /** 380 * @brief Retrieve the route number of the current recording device 381 * 382 * OSSv4 assigns routing numbers to recording devices, unlike the previous 383 * API which relied on a fixed table of device numbers and names. This 384 * function returns the routing number of the device currently selected 385 * for recording. 386 * 387 * For now, this function is kind of a goofy compatibility stub atop the 388 * existing sound system. (For example, in theory, the old sound system 389 * allows multiple recording devices to be specified via a bitmask.) 390 * 391 * @param m mixer context container thing 392 * 393 * @retval 0 success 394 * @retval EIDRM no recording device found (generally not possible) 395 * @todo Ask about error code 396 */ 397 static int 398 mixer_get_recroute(struct snd_mixer *m, int *route) 399 { 400 int i, cnt; 401 402 cnt = 0; 403 404 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 405 /** @todo can user set a multi-device mask? (== or &?) */ 406 if ((1 << i) == m->recsrc) 407 break; 408 if ((1 << i) & m->recdevs) 409 ++cnt; 410 } 411 412 if (i == SOUND_MIXER_NRDEVICES) 413 return EIDRM; 414 415 *route = cnt; 416 return 0; 417 } 418 419 /** 420 * @brief Select a device for recording 421 * 422 * This function sets a recording source based on a recording device's 423 * routing number. Said number is translated to an old school recdev 424 * mask and passed over mixer_setrecsrc. 425 * 426 * @param m mixer context container thing 427 * 428 * @retval 0 success(?) 429 * @retval EINVAL User specified an invalid device number 430 * @retval otherwise error from mixer_setrecsrc 431 */ 432 static int 433 mixer_set_recroute(struct snd_mixer *m, int route) 434 { 435 int i, cnt, ret; 436 437 ret = 0; 438 cnt = 0; 439 440 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 441 if ((1 << i) & m->recdevs) { 442 if (route == cnt) 443 break; 444 ++cnt; 445 } 446 } 447 448 if (i == SOUND_MIXER_NRDEVICES) 449 ret = EINVAL; 450 else 451 ret = mixer_setrecsrc(m, (1 << i)); 452 453 return ret; 454 } 455 456 void 457 mix_setdevs(struct snd_mixer *m, u_int32_t v) 458 { 459 struct snddev_info *d; 460 int i; 461 462 if (m == NULL) 463 return; 464 465 d = device_get_softc(m->dev); 466 if (d != NULL && (d->flags & SD_F_SOFTPCMVOL)) 467 v |= SOUND_MASK_PCM; 468 if (d != NULL && (d->flags & SD_F_EQ)) 469 v |= SOUND_MASK_TREBLE | SOUND_MASK_BASS; 470 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 471 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 472 v |= 1 << m->parent[i]; 473 v |= m->child[i]; 474 } 475 m->devs = v; 476 } 477 478 /** 479 * @brief Record mask of available recording devices 480 * 481 * Calling functions are responsible for defining the mask of available 482 * recording devices. This function records that value in a structure 483 * used by the rest of the mixer code. 484 * 485 * This function also populates a structure used by the SNDCTL_DSP_*RECSRC* 486 * family of ioctls that are part of OSSV4. All recording device labels 487 * are concatenated in ascending order corresponding to their routing 488 * numbers. (Ex: a system might have 0 => 'vol', 1 => 'cd', 2 => 'line', 489 * etc.) For now, these labels are just the standard recording device 490 * names (cd, line1, etc.), but will eventually be fully dynamic and user 491 * controlled. 492 * 493 * @param m mixer device context container thing 494 * @param v mask of recording devices 495 */ 496 void 497 mix_setrecdevs(struct snd_mixer *m, u_int32_t v) 498 { 499 oss_mixer_enuminfo *ei; 500 char *loc; 501 int i, nvalues, nwrote, nleft, ncopied; 502 503 ei = &m->enuminfo; 504 505 nvalues = 0; 506 nwrote = 0; 507 nleft = sizeof(ei->strings); 508 loc = ei->strings; 509 510 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 511 if ((1 << i) & v) { 512 ei->strindex[nvalues] = nwrote; 513 ncopied = strlcpy(loc, snd_mixernames[i], nleft) + 1; 514 /* strlcpy retval doesn't include terminator */ 515 516 nwrote += ncopied; 517 nleft -= ncopied; 518 nvalues++; 519 520 /* 521 * XXX I don't think this should ever be possible. 522 * Even with a move to dynamic device/channel names, 523 * each label is limited to ~16 characters, so that'd 524 * take a LOT to fill this buffer. 525 */ 526 if ((nleft <= 0) || (nvalues >= OSS_ENUM_MAXVALUE)) { 527 device_printf(m->dev, 528 "mix_setrecdevs: Not enough room to store device names--please file a bug report.\n"); 529 device_printf(m->dev, 530 "mix_setrecdevs: Please include details about your sound hardware, OS version, etc.\n"); 531 break; 532 } 533 534 loc = &ei->strings[nwrote]; 535 } 536 } 537 538 /* 539 * NB: The SNDCTL_DSP_GET_RECSRC_NAMES ioctl ignores the dev 540 * and ctrl fields. 541 */ 542 ei->nvalues = nvalues; 543 m->recdevs = v; 544 } 545 546 void 547 mix_setparentchild(struct snd_mixer *m, u_int32_t parent, u_int32_t childs) 548 { 549 u_int32_t mask = 0; 550 int i; 551 552 if (m == NULL || parent >= SOUND_MIXER_NRDEVICES) 553 return; 554 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 555 if (i == parent) 556 continue; 557 if (childs & (1 << i)) { 558 mask |= 1 << i; 559 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 560 m->child[m->parent[i]] &= ~(1 << i); 561 m->parent[i] = parent; 562 m->child[i] = 0; 563 } 564 } 565 mask &= ~(1 << parent); 566 m->child[parent] = mask; 567 } 568 569 void 570 mix_setrealdev(struct snd_mixer *m, u_int32_t dev, u_int32_t realdev) 571 { 572 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES || 573 !(realdev == SOUND_MIXER_NONE || realdev < SOUND_MIXER_NRDEVICES)) 574 return; 575 m->realdev[dev] = realdev; 576 } 577 578 u_int32_t 579 mix_getparent(struct snd_mixer *m, u_int32_t dev) 580 { 581 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES) 582 return SOUND_MIXER_NONE; 583 return m->parent[dev]; 584 } 585 586 u_int32_t 587 mix_getchild(struct snd_mixer *m, u_int32_t dev) 588 { 589 if (m == NULL || dev >= SOUND_MIXER_NRDEVICES) 590 return 0; 591 return m->child[dev]; 592 } 593 594 u_int32_t 595 mix_getdevs(struct snd_mixer *m) 596 { 597 return m->devs; 598 } 599 600 u_int32_t 601 mix_getrecdevs(struct snd_mixer *m) 602 { 603 return m->recdevs; 604 } 605 606 void * 607 mix_getdevinfo(struct snd_mixer *m) 608 { 609 return m->devinfo; 610 } 611 612 static struct snd_mixer * 613 mixer_obj_create(device_t dev, kobj_class_t cls, void *devinfo, 614 int type, const char *desc) 615 { 616 struct snd_mixer *m; 617 int i; 618 619 KASSERT(dev != NULL && cls != NULL && devinfo != NULL, 620 ("%s(): NULL data dev=%p cls=%p devinfo=%p", 621 __func__, dev, cls, devinfo)); 622 KASSERT(type == MIXER_TYPE_PRIMARY || type == MIXER_TYPE_SECONDARY, 623 ("invalid mixer type=%d", type)); 624 625 m = (struct snd_mixer *)kobj_create(cls, M_MIXER, M_WAITOK | M_ZERO); 626 snprintf(m->name, sizeof(m->name), "%s:mixer", 627 device_get_nameunit(dev)); 628 if (desc != NULL) { 629 strlcat(m->name, ":", sizeof(m->name)); 630 strlcat(m->name, desc, sizeof(m->name)); 631 } 632 m->lock = snd_mtxcreate(m->name, (type == MIXER_TYPE_PRIMARY) ? 633 "primary pcm mixer" : "secondary pcm mixer"); 634 m->type = type; 635 m->devinfo = devinfo; 636 m->busy = 0; 637 m->dev = dev; 638 for (i = 0; i < (sizeof(m->parent) / sizeof(m->parent[0])); i++) { 639 m->parent[i] = SOUND_MIXER_NONE; 640 m->child[i] = 0; 641 m->realdev[i] = i; 642 } 643 644 if (MIXER_INIT(m)) { 645 snd_mtxlock(m->lock); 646 snd_mtxfree(m->lock); 647 kobj_delete((kobj_t)m, M_MIXER); 648 return (NULL); 649 } 650 651 return (m); 652 } 653 654 int 655 mixer_delete(struct snd_mixer *m) 656 { 657 KASSERT(m != NULL, ("NULL snd_mixer")); 658 KASSERT(m->type == MIXER_TYPE_SECONDARY, 659 ("%s(): illegal mixer type=%d", __func__, m->type)); 660 661 /* mixer uninit can sleep --hps */ 662 663 MIXER_UNINIT(m); 664 665 snd_mtxfree(m->lock); 666 kobj_delete((kobj_t)m, M_MIXER); 667 668 --mixer_count; 669 670 return (0); 671 } 672 673 struct snd_mixer * 674 mixer_create(device_t dev, kobj_class_t cls, void *devinfo, const char *desc) 675 { 676 struct snd_mixer *m; 677 678 m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_SECONDARY, desc); 679 680 if (m != NULL) 681 ++mixer_count; 682 683 return (m); 684 } 685 686 int 687 mixer_init(device_t dev, kobj_class_t cls, void *devinfo) 688 { 689 struct snddev_info *snddev; 690 struct snd_mixer *m; 691 u_int16_t v; 692 struct cdev *pdev; 693 int i, unit, devunit, val; 694 695 snddev = device_get_softc(dev); 696 if (snddev == NULL) 697 return (-1); 698 699 if (resource_int_value(device_get_name(dev), 700 device_get_unit(dev), "eq", &val) == 0 && val != 0) { 701 snddev->flags |= SD_F_EQ; 702 if ((val & SD_F_EQ_MASK) == val) 703 snddev->flags |= val; 704 else 705 snddev->flags |= SD_F_EQ_DEFAULT; 706 snddev->eqpreamp = 0; 707 } 708 709 m = mixer_obj_create(dev, cls, devinfo, MIXER_TYPE_PRIMARY, NULL); 710 if (m == NULL) 711 return (-1); 712 713 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 714 v = snd_mixerdefaults[i]; 715 716 if (resource_int_value(device_get_name(dev), 717 device_get_unit(dev), snd_mixernames[i], &val) == 0) { 718 if (val >= 0 && val <= 100) { 719 v = (u_int16_t) val; 720 } 721 } 722 723 mixer_set(m, i, v | (v << 8)); 724 } 725 726 mixer_setrecsrc(m, 0); /* Set default input. */ 727 728 unit = device_get_unit(dev); 729 devunit = snd_mkunit(unit, SND_DEV_CTL, 0); 730 pdev = make_dev(&mixer_cdevsw, PCMMINOR(devunit), 731 UID_ROOT, GID_WHEEL, 0666, "mixer%d", unit); 732 pdev->si_drv1 = m; 733 snddev->mixer_dev = pdev; 734 735 ++mixer_count; 736 737 if (bootverbose) { 738 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) { 739 if (!(m->devs & (1 << i))) 740 continue; 741 if (m->realdev[i] != i) { 742 device_printf(dev, "Mixer \"%s\" -> \"%s\":", 743 snd_mixernames[i], 744 (m->realdev[i] < SOUND_MIXER_NRDEVICES) ? 745 snd_mixernames[m->realdev[i]] : "none"); 746 } else { 747 device_printf(dev, "Mixer \"%s\":", 748 snd_mixernames[i]); 749 } 750 if (m->parent[i] < SOUND_MIXER_NRDEVICES) 751 printf(" parent=\"%s\"", 752 snd_mixernames[m->parent[i]]); 753 if (m->child[i] != 0) 754 printf(" child=0x%08x", m->child[i]); 755 printf("\n"); 756 } 757 if (snddev->flags & SD_F_SOFTPCMVOL) 758 device_printf(dev, "Soft PCM mixer ENABLED\n"); 759 if (snddev->flags & SD_F_EQ) 760 device_printf(dev, "EQ Treble/Bass ENABLED\n"); 761 } 762 763 return (0); 764 } 765 766 int 767 mixer_uninit(device_t dev) 768 { 769 int i; 770 struct snddev_info *d; 771 struct snd_mixer *m; 772 struct cdev *pdev; 773 774 d = device_get_softc(dev); 775 pdev = mixer_get_devt(dev); 776 if (d == NULL || pdev == NULL || pdev->si_drv1 == NULL) 777 return EBADF; 778 779 m = pdev->si_drv1; 780 KASSERT(m != NULL, ("NULL snd_mixer")); 781 KASSERT(m->type == MIXER_TYPE_PRIMARY, 782 ("%s(): illegal mixer type=%d", __func__, m->type)); 783 784 snd_mtxlock(m->lock); 785 786 if (m->busy) { 787 snd_mtxunlock(m->lock); 788 return EBUSY; 789 } 790 791 /* destroy dev can sleep --hps */ 792 793 snd_mtxunlock(m->lock); 794 795 pdev->si_drv1 = NULL; 796 destroy_dev(pdev); 797 798 snd_mtxlock(m->lock); 799 800 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 801 mixer_set(m, i, 0); 802 803 mixer_setrecsrc(m, SOUND_MASK_MIC); 804 805 snd_mtxunlock(m->lock); 806 807 /* mixer uninit can sleep --hps */ 808 809 MIXER_UNINIT(m); 810 811 snd_mtxfree(m->lock); 812 kobj_delete((kobj_t)m, M_MIXER); 813 814 d->mixer_dev = NULL; 815 816 --mixer_count; 817 818 return 0; 819 } 820 821 int 822 mixer_reinit(device_t dev) 823 { 824 struct snd_mixer *m; 825 struct cdev *pdev; 826 int i; 827 828 pdev = mixer_get_devt(dev); 829 m = pdev->si_drv1; 830 snd_mtxlock(m->lock); 831 832 i = MIXER_REINIT(m); 833 if (i) { 834 snd_mtxunlock(m->lock); 835 return i; 836 } 837 838 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) 839 mixer_set(m, i, m->level[i]); 840 841 mixer_setrecsrc(m, m->recsrc); 842 snd_mtxunlock(m->lock); 843 844 return 0; 845 } 846 847 static int 848 sysctl_hw_snd_hwvol_mixer(SYSCTL_HANDLER_ARGS) 849 { 850 char devname[32]; 851 int error, dev; 852 struct snd_mixer *m; 853 854 m = oidp->oid_arg1; 855 snd_mtxlock(m->lock); 856 strlcpy(devname, snd_mixernames[m->hwvol_mixer], sizeof(devname)); 857 snd_mtxunlock(m->lock); 858 error = sysctl_handle_string(oidp, &devname[0], sizeof(devname), req); 859 snd_mtxlock(m->lock); 860 if (error == 0 && req->newptr != NULL) { 861 dev = mixer_lookup(devname); 862 if (dev == -1) { 863 snd_mtxunlock(m->lock); 864 return EINVAL; 865 } 866 else if (dev != m->hwvol_mixer) { 867 m->hwvol_mixer = dev; 868 m->hwvol_muted = 0; 869 } 870 } 871 snd_mtxunlock(m->lock); 872 return error; 873 } 874 875 int 876 mixer_hwvol_init(device_t dev) 877 { 878 struct snd_mixer *m; 879 struct cdev *pdev; 880 881 pdev = mixer_get_devt(dev); 882 m = pdev->si_drv1; 883 884 m->hwvol_mixer = SOUND_MIXER_VOLUME; 885 m->hwvol_step = 5; 886 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev), 887 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 888 OID_AUTO, "hwvol_step", CTLFLAG_RW, &m->hwvol_step, 0, ""); 889 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev), 890 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), 891 OID_AUTO, "hwvol_mixer", CTLTYPE_STRING | CTLFLAG_RW, m, 0, 892 sysctl_hw_snd_hwvol_mixer, "A", ""); 893 return 0; 894 } 895 896 void 897 mixer_hwvol_mute_locked(struct snd_mixer *m) 898 { 899 if (m->hwvol_muted) { 900 m->hwvol_muted = 0; 901 mixer_set(m, m->hwvol_mixer, m->hwvol_mute_level); 902 } else { 903 m->hwvol_muted++; 904 m->hwvol_mute_level = mixer_get(m, m->hwvol_mixer); 905 mixer_set(m, m->hwvol_mixer, 0); 906 } 907 } 908 909 void 910 mixer_hwvol_mute(device_t dev) 911 { 912 struct snd_mixer *m; 913 struct cdev *pdev; 914 915 pdev = mixer_get_devt(dev); 916 m = pdev->si_drv1; 917 snd_mtxlock(m->lock); 918 mixer_hwvol_mute_locked(m); 919 snd_mtxunlock(m->lock); 920 } 921 922 void 923 mixer_hwvol_step_locked(struct snd_mixer *m, int left_step, int right_step) 924 { 925 int level, left, right; 926 927 if (m->hwvol_muted) { 928 m->hwvol_muted = 0; 929 level = m->hwvol_mute_level; 930 } else 931 level = mixer_get(m, m->hwvol_mixer); 932 if (level != -1) { 933 left = level & 0xff; 934 right = (level >> 8) & 0xff; 935 left += left_step * m->hwvol_step; 936 if (left < 0) 937 left = 0; 938 else if (left > 100) 939 left = 100; 940 right += right_step * m->hwvol_step; 941 if (right < 0) 942 right = 0; 943 else if (right > 100) 944 right = 100; 945 mixer_set(m, m->hwvol_mixer, left | right << 8); 946 } 947 } 948 949 void 950 mixer_hwvol_step(device_t dev, int left_step, int right_step) 951 { 952 struct snd_mixer *m; 953 struct cdev *pdev; 954 955 pdev = mixer_get_devt(dev); 956 m = pdev->si_drv1; 957 snd_mtxlock(m->lock); 958 mixer_hwvol_step_locked(m, left_step, right_step); 959 snd_mtxunlock(m->lock); 960 } 961 962 int 963 mixer_busy(struct snd_mixer *m) 964 { 965 KASSERT(m != NULL, ("NULL snd_mixer")); 966 967 return (m->busy); 968 } 969 970 int 971 mix_set(struct snd_mixer *m, u_int dev, u_int left, u_int right) 972 { 973 int ret; 974 975 KASSERT(m != NULL, ("NULL snd_mixer")); 976 977 snd_mtxlock(m->lock); 978 ret = mixer_set(m, dev, left | (right << 8)); 979 snd_mtxunlock(m->lock); 980 981 return ((ret != 0) ? ENXIO : 0); 982 } 983 984 int 985 mix_get(struct snd_mixer *m, u_int dev) 986 { 987 int ret; 988 989 KASSERT(m != NULL, ("NULL snd_mixer")); 990 991 snd_mtxlock(m->lock); 992 ret = mixer_get(m, dev); 993 snd_mtxunlock(m->lock); 994 995 return (ret); 996 } 997 998 int 999 mix_setrecsrc(struct snd_mixer *m, u_int32_t src) 1000 { 1001 int ret; 1002 1003 KASSERT(m != NULL, ("NULL snd_mixer")); 1004 1005 snd_mtxlock(m->lock); 1006 ret = mixer_setrecsrc(m, src); 1007 snd_mtxunlock(m->lock); 1008 1009 return ((ret != 0) ? ENXIO : 0); 1010 } 1011 1012 u_int32_t 1013 mix_getrecsrc(struct snd_mixer *m) 1014 { 1015 u_int32_t ret; 1016 1017 KASSERT(m != NULL, ("NULL snd_mixer")); 1018 1019 snd_mtxlock(m->lock); 1020 ret = mixer_getrecsrc(m); 1021 snd_mtxunlock(m->lock); 1022 1023 return (ret); 1024 } 1025 1026 int 1027 mix_get_type(struct snd_mixer *m) 1028 { 1029 KASSERT(m != NULL, ("NULL snd_mixer")); 1030 1031 return (m->type); 1032 } 1033 1034 device_t 1035 mix_get_dev(struct snd_mixer *m) 1036 { 1037 KASSERT(m != NULL, ("NULL snd_mixer")); 1038 1039 return (m->dev); 1040 } 1041 1042 /* ----------------------------------------------------------------------- */ 1043 1044 static int 1045 mixer_open(struct cdev *i_dev, int flags, int mode, struct thread *td) 1046 { 1047 struct snddev_info *d; 1048 struct snd_mixer *m; 1049 1050 1051 if (i_dev == NULL || i_dev->si_drv1 == NULL) 1052 return (EBADF); 1053 1054 m = i_dev->si_drv1; 1055 d = device_get_softc(m->dev); 1056 if (PCM_DETACHING(d) || !PCM_REGISTERED(d)) 1057 return (EBADF); 1058 1059 /* XXX Need Giant magic entry ??? */ 1060 1061 snd_mtxlock(m->lock); 1062 m->busy = 1; 1063 snd_mtxunlock(m->lock); 1064 1065 return (0); 1066 } 1067 1068 static int 1069 mixer_close(struct cdev *i_dev, int flags, int mode, struct thread *td) 1070 { 1071 struct snddev_info *d; 1072 struct snd_mixer *m; 1073 int ret; 1074 1075 if (i_dev == NULL || i_dev->si_drv1 == NULL) 1076 return (EBADF); 1077 1078 m = i_dev->si_drv1; 1079 d = device_get_softc(m->dev); 1080 if (!PCM_REGISTERED(d)) 1081 return (EBADF); 1082 1083 /* XXX Need Giant magic entry ??? */ 1084 1085 snd_mtxlock(m->lock); 1086 ret = (m->busy == 0) ? EBADF : 0; 1087 m->busy = 0; 1088 snd_mtxunlock(m->lock); 1089 1090 return (ret); 1091 } 1092 1093 static int 1094 mixer_ioctl_channel(struct cdev *dev, u_long cmd, caddr_t arg, int mode, 1095 struct thread *td, int from) 1096 { 1097 struct snddev_info *d; 1098 struct snd_mixer *m; 1099 struct pcm_channel *c, *rdch, *wrch; 1100 pid_t pid; 1101 int j, ret; 1102 1103 if (td == NULL || td->td_proc == NULL) 1104 return (-1); 1105 1106 m = dev->si_drv1; 1107 d = device_get_softc(m->dev); 1108 j = cmd & 0xff; 1109 1110 switch (j) { 1111 case SOUND_MIXER_PCM: 1112 case SOUND_MIXER_RECLEV: 1113 case SOUND_MIXER_DEVMASK: 1114 case SOUND_MIXER_CAPS: 1115 case SOUND_MIXER_STEREODEVS: 1116 break; 1117 default: 1118 return (-1); 1119 break; 1120 } 1121 1122 pid = td->td_proc->p_pid; 1123 rdch = NULL; 1124 wrch = NULL; 1125 c = NULL; 1126 ret = -1; 1127 1128 /* 1129 * This is unfair. Imagine single proc opening multiple 1130 * instances of same direction. What we do right now 1131 * is looking for the first matching proc/pid, and just 1132 * that. Nothing more. Consider it done. 1133 * 1134 * The better approach of controlling specific channel 1135 * pcm or rec volume is by doing mixer ioctl 1136 * (SNDCTL_DSP_[SET|GET][PLAY|REC]VOL / SOUND_MIXER_[PCM|RECLEV] 1137 * on its open fd, rather than cracky mixer bypassing here. 1138 */ 1139 CHN_FOREACH(c, d, channels.pcm.opened) { 1140 CHN_LOCK(c); 1141 if (c->pid != pid || 1142 !(c->feederflags & (1 << FEEDER_VOLUME))) { 1143 CHN_UNLOCK(c); 1144 continue; 1145 } 1146 if (rdch == NULL && c->direction == PCMDIR_REC) { 1147 rdch = c; 1148 if (j == SOUND_MIXER_RECLEV) 1149 goto mixer_ioctl_channel_proc; 1150 } else if (wrch == NULL && c->direction == PCMDIR_PLAY) { 1151 wrch = c; 1152 if (j == SOUND_MIXER_PCM) 1153 goto mixer_ioctl_channel_proc; 1154 } 1155 CHN_UNLOCK(c); 1156 if (rdch != NULL && wrch != NULL) 1157 break; 1158 } 1159 1160 if (rdch == NULL && wrch == NULL) 1161 return (-1); 1162 1163 if ((j == SOUND_MIXER_DEVMASK || j == SOUND_MIXER_CAPS || 1164 j == SOUND_MIXER_STEREODEVS) && 1165 (cmd & ~0xff) == MIXER_READ(0)) { 1166 snd_mtxlock(m->lock); 1167 *(int *)arg = mix_getdevs(m); 1168 snd_mtxunlock(m->lock); 1169 if (rdch != NULL) 1170 *(int *)arg |= SOUND_MASK_RECLEV; 1171 if (wrch != NULL) 1172 *(int *)arg |= SOUND_MASK_PCM; 1173 ret = 0; 1174 } 1175 1176 return (ret); 1177 1178 mixer_ioctl_channel_proc: 1179 1180 KASSERT(c != NULL, ("%s(): NULL channel", __func__)); 1181 CHN_LOCKASSERT(c); 1182 1183 if ((cmd & ~0xff) == MIXER_WRITE(0)) { 1184 int left, right, center; 1185 1186 left = *(int *)arg & 0x7f; 1187 right = (*(int *)arg >> 8) & 0x7f; 1188 center = (left + right) >> 1; 1189 chn_setvolume_multi(c, SND_VOL_C_PCM, left, right, center); 1190 } else if ((cmd & ~0xff) == MIXER_READ(0)) { 1191 *(int *)arg = CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FL); 1192 *(int *)arg |= 1193 CHN_GETVOLUME(c, SND_VOL_C_PCM, SND_CHN_T_FR) << 8; 1194 } 1195 1196 CHN_UNLOCK(c); 1197 1198 return (0); 1199 } 1200 1201 static int 1202 mixer_ioctl(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, 1203 struct thread *td) 1204 { 1205 struct snddev_info *d; 1206 int ret; 1207 1208 if (i_dev == NULL || i_dev->si_drv1 == NULL) 1209 return (EBADF); 1210 1211 d = device_get_softc(((struct snd_mixer *)i_dev->si_drv1)->dev); 1212 if (PCM_DETACHING(d) || !PCM_REGISTERED(d)) 1213 return (EBADF); 1214 1215 PCM_GIANT_ENTER(d); 1216 PCM_ACQUIRE_QUICK(d); 1217 1218 ret = -1; 1219 1220 if (mixer_bypass != 0 && (d->flags & SD_F_VPC)) 1221 ret = mixer_ioctl_channel(i_dev, cmd, arg, mode, td, 1222 MIXER_CMD_CDEV); 1223 1224 if (ret == -1) 1225 ret = mixer_ioctl_cmd(i_dev, cmd, arg, mode, td, 1226 MIXER_CMD_CDEV); 1227 1228 PCM_RELEASE_QUICK(d); 1229 PCM_GIANT_LEAVE(d); 1230 1231 return (ret); 1232 } 1233 1234 static void 1235 mixer_mixerinfo(struct snd_mixer *m, mixer_info *mi) 1236 { 1237 bzero((void *)mi, sizeof(*mi)); 1238 strlcpy(mi->id, m->name, sizeof(mi->id)); 1239 strlcpy(mi->name, device_get_desc(m->dev), sizeof(mi->name)); 1240 mi->modify_counter = m->modify_counter; 1241 } 1242 1243 /* 1244 * XXX Make sure you can guarantee concurrency safety before calling this 1245 * function, be it through Giant, PCM_*, etc ! 1246 */ 1247 int 1248 mixer_ioctl_cmd(struct cdev *i_dev, u_long cmd, caddr_t arg, int mode, 1249 struct thread *td, int from) 1250 { 1251 struct snd_mixer *m; 1252 int ret = EINVAL, *arg_i = (int *)arg; 1253 int v = -1, j = cmd & 0xff; 1254 1255 /* 1256 * Certain ioctls may be made on any type of device (audio, mixer, 1257 * and MIDI). Handle those special cases here. 1258 */ 1259 if (IOCGROUP(cmd) == 'X') { 1260 switch (cmd) { 1261 case SNDCTL_SYSINFO: 1262 sound_oss_sysinfo((oss_sysinfo *)arg); 1263 return (0); 1264 case SNDCTL_CARDINFO: 1265 return (sound_oss_card_info((oss_card_info *)arg)); 1266 case SNDCTL_AUDIOINFO: 1267 case SNDCTL_AUDIOINFO_EX: 1268 case SNDCTL_ENGINEINFO: 1269 return (dsp_oss_audioinfo(i_dev, (oss_audioinfo *)arg)); 1270 case SNDCTL_MIXERINFO: 1271 return (mixer_oss_mixerinfo(i_dev, (oss_mixerinfo *)arg)); 1272 } 1273 return (EINVAL); 1274 } 1275 1276 m = i_dev->si_drv1; 1277 1278 if (m == NULL) 1279 return (EBADF); 1280 1281 snd_mtxlock(m->lock); 1282 if (from == MIXER_CMD_CDEV && !m->busy) { 1283 snd_mtxunlock(m->lock); 1284 return (EBADF); 1285 } 1286 switch (cmd) { 1287 case SNDCTL_DSP_GET_RECSRC_NAMES: 1288 bcopy((void *)&m->enuminfo, arg, sizeof(oss_mixer_enuminfo)); 1289 ret = 0; 1290 goto done; 1291 case SNDCTL_DSP_GET_RECSRC: 1292 ret = mixer_get_recroute(m, arg_i); 1293 goto done; 1294 case SNDCTL_DSP_SET_RECSRC: 1295 ret = mixer_set_recroute(m, *arg_i); 1296 goto done; 1297 case OSS_GETVERSION: 1298 *arg_i = SOUND_VERSION; 1299 ret = 0; 1300 goto done; 1301 case SOUND_MIXER_INFO: 1302 mixer_mixerinfo(m, (mixer_info *)arg); 1303 ret = 0; 1304 goto done; 1305 } 1306 if ((cmd & ~0xff) == MIXER_WRITE(0)) { 1307 if (j == SOUND_MIXER_RECSRC) 1308 ret = mixer_setrecsrc(m, *arg_i); 1309 else 1310 ret = mixer_set(m, j, *arg_i); 1311 snd_mtxunlock(m->lock); 1312 return ((ret == 0) ? 0 : ENXIO); 1313 } 1314 if ((cmd & ~0xff) == MIXER_READ(0)) { 1315 switch (j) { 1316 case SOUND_MIXER_DEVMASK: 1317 case SOUND_MIXER_CAPS: 1318 case SOUND_MIXER_STEREODEVS: 1319 v = mix_getdevs(m); 1320 break; 1321 case SOUND_MIXER_RECMASK: 1322 v = mix_getrecdevs(m); 1323 break; 1324 case SOUND_MIXER_RECSRC: 1325 v = mixer_getrecsrc(m); 1326 break; 1327 default: 1328 v = mixer_get(m, j); 1329 } 1330 *arg_i = v; 1331 snd_mtxunlock(m->lock); 1332 return ((v != -1) ? 0 : ENXIO); 1333 } 1334 done: 1335 snd_mtxunlock(m->lock); 1336 return (ret); 1337 } 1338 1339 static void 1340 mixer_clone(void *arg, 1341 #if __FreeBSD_version >= 600034 1342 struct ucred *cred, 1343 #endif 1344 char *name, int namelen, struct cdev **dev) 1345 { 1346 struct snddev_info *d; 1347 1348 if (*dev != NULL) 1349 return; 1350 if (strcmp(name, "mixer") == 0) { 1351 d = devclass_get_softc(pcm_devclass, snd_unit); 1352 if (PCM_REGISTERED(d) && d->mixer_dev != NULL) { 1353 *dev = d->mixer_dev; 1354 dev_ref(*dev); 1355 } 1356 } 1357 } 1358 1359 static void 1360 mixer_sysinit(void *p) 1361 { 1362 if (mixer_ehtag != NULL) 1363 return; 1364 mixer_ehtag = EVENTHANDLER_REGISTER(dev_clone, mixer_clone, 0, 1000); 1365 } 1366 1367 static void 1368 mixer_sysuninit(void *p) 1369 { 1370 if (mixer_ehtag == NULL) 1371 return; 1372 EVENTHANDLER_DEREGISTER(dev_clone, mixer_ehtag); 1373 mixer_ehtag = NULL; 1374 } 1375 1376 SYSINIT(mixer_sysinit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysinit, NULL); 1377 SYSUNINIT(mixer_sysuninit, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, mixer_sysuninit, NULL); 1378 1379 /** 1380 * @brief Handler for SNDCTL_MIXERINFO 1381 * 1382 * This function searches for a mixer based on the numeric ID stored 1383 * in oss_miserinfo::dev. If set to -1, then information about the 1384 * current mixer handling the request is provided. Note, however, that 1385 * this ioctl may be made with any sound device (audio, mixer, midi). 1386 * 1387 * @note Caller must not hold any PCM device, channel, or mixer locks. 1388 * 1389 * See http://manuals.opensound.com/developer/SNDCTL_MIXERINFO.html for 1390 * more information. 1391 * 1392 * @param i_dev character device on which the ioctl arrived 1393 * @param arg user argument (oss_mixerinfo *) 1394 * 1395 * @retval EINVAL oss_mixerinfo::dev specified a bad value 1396 * @retval 0 success 1397 */ 1398 int 1399 mixer_oss_mixerinfo(struct cdev *i_dev, oss_mixerinfo *mi) 1400 { 1401 struct snddev_info *d; 1402 struct snd_mixer *m; 1403 int nmix, i; 1404 1405 /* 1406 * If probing the device handling the ioctl, make sure it's a mixer 1407 * device. (This ioctl is valid on audio, mixer, and midi devices.) 1408 */ 1409 if (mi->dev == -1 && i_dev->si_devsw != &mixer_cdevsw) 1410 return (EINVAL); 1411 1412 d = NULL; 1413 m = NULL; 1414 nmix = 0; 1415 1416 /* 1417 * There's a 1:1 relationship between mixers and PCM devices, so 1418 * begin by iterating over PCM devices and search for our mixer. 1419 */ 1420 for (i = 0; pcm_devclass != NULL && 1421 i < devclass_get_maxunit(pcm_devclass); i++) { 1422 d = devclass_get_softc(pcm_devclass, i); 1423 if (PCM_DETACHING(d) || !PCM_REGISTERED(d)) 1424 continue; 1425 1426 /* XXX Need Giant magic entry */ 1427 1428 /* See the note in function docblock. */ 1429 PCM_UNLOCKASSERT(d); 1430 PCM_LOCK(d); 1431 1432 if (d->mixer_dev != NULL && d->mixer_dev->si_drv1 != NULL && 1433 ((mi->dev == -1 && d->mixer_dev == i_dev) || 1434 mi->dev == nmix)) { 1435 m = d->mixer_dev->si_drv1; 1436 mtx_lock(m->lock); 1437 1438 /* 1439 * At this point, the following synchronization stuff 1440 * has happened: 1441 * - a specific PCM device is locked. 1442 * - a specific mixer device has been locked, so be 1443 * sure to unlock when existing. 1444 */ 1445 bzero((void *)mi, sizeof(*mi)); 1446 mi->dev = nmix; 1447 snprintf(mi->id, sizeof(mi->id), "mixer%d", i); 1448 strlcpy(mi->name, m->name, sizeof(mi->name)); 1449 mi->modify_counter = m->modify_counter; 1450 mi->card_number = i; 1451 /* 1452 * Currently, FreeBSD assumes 1:1 relationship between 1453 * a pcm and mixer devices, so this is hardcoded to 0. 1454 */ 1455 mi->port_number = 0; 1456 1457 /** 1458 * @todo Fill in @sa oss_mixerinfo::mixerhandle. 1459 * @note From 4Front: "mixerhandle is an arbitrary 1460 * string that identifies the mixer better than 1461 * the device number (mixerinfo.dev). Device 1462 * numbers may change depending on the order the 1463 * drivers are loaded. However the handle should 1464 * remain the same provided that the sound card 1465 * is not moved to another PCI slot." 1466 */ 1467 1468 /** 1469 * @note 1470 * @sa oss_mixerinfo::magic is a reserved field. 1471 * 1472 * @par 1473 * From 4Front: "magic is usually 0. However some 1474 * devices may have dedicated setup utilities and the 1475 * magic field may contain an unique driver specific 1476 * value (managed by [4Front])." 1477 */ 1478 1479 mi->enabled = device_is_attached(m->dev) ? 1 : 0; 1480 /** 1481 * The only flag for @sa oss_mixerinfo::caps is 1482 * currently MIXER_CAP_VIRTUAL, which I'm not sure we 1483 * really worry about. 1484 */ 1485 /** 1486 * Mixer extensions currently aren't supported, so 1487 * leave @sa oss_mixerinfo::nrext blank for now. 1488 */ 1489 /** 1490 * @todo Fill in @sa oss_mixerinfo::priority (requires 1491 * touching drivers?) 1492 * @note The priority field is for mixer applets to 1493 * determine which mixer should be the default, with 0 1494 * being least preferred and 10 being most preferred. 1495 * From 4Front: "OSS drivers like ICH use higher 1496 * values (10) because such chips are known to be used 1497 * only on motherboards. Drivers for high end pro 1498 * devices use 0 because they will never be the 1499 * default mixer. Other devices use values 1 to 9 1500 * depending on the estimated probability of being the 1501 * default device. 1502 * 1503 * XXX Described by Hannu@4Front, but not found in 1504 * soundcard.h. 1505 strlcpy(mi->devnode, devtoname(d->mixer_dev), 1506 sizeof(mi->devnode)); 1507 mi->legacy_device = i; 1508 */ 1509 mtx_unlock(m->lock); 1510 } else 1511 ++nmix; 1512 1513 PCM_UNLOCK(d); 1514 1515 if (m != NULL) 1516 return (0); 1517 } 1518 1519 return (EINVAL); 1520 } 1521 1522 /* 1523 * Allow the sound driver to use the mixer lock to protect its mixer 1524 * data: 1525 */ 1526 struct mtx * 1527 mixer_get_lock(struct snd_mixer *m) 1528 { 1529 if (m->lock == NULL) { 1530 return (&Giant); 1531 } 1532 return (m->lock); 1533 } 1534 1535 int 1536 mix_get_locked(struct snd_mixer *m, u_int dev, int *pleft, int *pright) 1537 { 1538 int level; 1539 1540 level = mixer_get(m, dev); 1541 if (level < 0) { 1542 *pright = *pleft = -1; 1543 return (-1); 1544 } 1545 1546 *pleft = level & 0xFF; 1547 *pright = (level >> 8) & 0xFF; 1548 1549 return (0); 1550 } 1551 1552 int 1553 mix_set_locked(struct snd_mixer *m, u_int dev, int left, int right) 1554 { 1555 int level; 1556 1557 level = (left & 0xFF) | ((right & 0xFF) << 8); 1558 1559 return (mixer_set(m, dev, level)); 1560 }
Cache object: deec5569d8f285abeea9214bb4c3731c
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]